void GameObject::get_polygon(int index, PolygonFace &polygon) const
{
PolygonFace *original_polygon = get_original_polygon(index);
polygon.remove_vertices();
for (int i = 0; i < original_polygon->get_vertex_count(); ++i) {
polygon.add_vertex(new glm::vec3(*(original_polygon->get_vertex(i))));
}
update_polygon(polygon);
}
BSP_Node* GameObject::build_bsp_tree()
{
if (get_polygon_count() == 0)
return 0;
std::vector<PolygonFace *> polygons;
for (int i = 0; i < get_polygon_count(); ++i) {
PolygonFace *polygon = new PolygonFace(get_original_polygon(i));
update_polygon(*polygon);
polygons.push_back(polygon);
}
BSP_Node *bsp_root = new BSP_Node();
make_bsp_node(bsp_root, polygons);
return bsp_root;
}
/**
* Compute derived GL state.
* If __GLcontextRec::NewState is non-zero then this function \b must
* be called before rendering anything.
*
* Calls dd_function_table::UpdateState to perform any internal state
* management necessary.
*
* \sa _mesa_update_modelview_project(), _mesa_update_texture(),
* _mesa_update_buffer_bounds(),
* _mesa_update_lighting() and _mesa_update_tnl_spaces().
*/
void
_mesa_update_state_locked( GLcontext *ctx )
{
GLbitfield new_state = ctx->NewState;
GLbitfield prog_flags = _NEW_PROGRAM;
GLbitfield new_prog_state = 0x0;
if (new_state == _NEW_CURRENT_ATTRIB)
goto out;
if (MESA_VERBOSE & VERBOSE_STATE)
_mesa_print_state("_mesa_update_state", new_state);
/* Determine which state flags effect vertex/fragment program state */
if (ctx->FragmentProgram._MaintainTexEnvProgram) {
prog_flags |= (_NEW_TEXTURE | _NEW_FOG | _DD_NEW_SEPARATE_SPECULAR |
_NEW_ARRAY);
}
if (ctx->VertexProgram._MaintainTnlProgram) {
prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
_NEW_TRANSFORM | _NEW_POINT |
_NEW_FOG | _NEW_LIGHT |
_MESA_NEW_NEED_EYE_COORDS);
}
/*
* Now update derived state info
*/
if (new_state & prog_flags)
update_program_enables( ctx );
if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
_mesa_update_modelview_project( ctx, new_state );
if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))
_mesa_update_texture( ctx, new_state );
if (new_state & _NEW_BUFFERS)
_mesa_update_framebuffer(ctx);
if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))
_mesa_update_draw_buffer_bounds( ctx );
if (new_state & _NEW_POLYGON)
update_polygon( ctx );
if (new_state & _NEW_LIGHT)
_mesa_update_lighting( ctx );
if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
_mesa_update_stencil( ctx );
#if FEATURE_pixel_transfer
if (new_state & _MESA_NEW_TRANSFER_STATE)
_mesa_update_pixel( ctx, new_state );
#endif
if (new_state & _DD_NEW_SEPARATE_SPECULAR)
update_separate_specular( ctx );
if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
update_arrays( ctx );
if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
update_viewport_matrix(ctx);
if (new_state & _NEW_MULTISAMPLE)
update_multisample( ctx );
if (new_state & _NEW_COLOR)
update_color( ctx );
#if 0
if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT
| _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))
update_tricaps( ctx, new_state );
#endif
/* ctx->_NeedEyeCoords is now up to date.
*
* If the truth value of this variable has changed, update for the
* new lighting space and recompute the positions of lights and the
* normal transform.
*
* If the lighting space hasn't changed, may still need to recompute
* light positions & normal transforms for other reasons.
*/
if (new_state & _MESA_NEW_NEED_EYE_COORDS)
_mesa_update_tnl_spaces( ctx, new_state );
if (new_state & prog_flags) {
/* When we generate programs from fixed-function vertex/fragment state
* this call may generate/bind a new program. If so, we need to
* propogate the _NEW_PROGRAM flag to the driver.
*/
new_prog_state |= update_program( ctx );
}
out:
new_prog_state |= update_program_constants(ctx);
/*
* Give the driver a chance to act upon the new_state flags.
* The driver might plug in different span functions, for example.
* Also, this is where the driver can invalidate the state of any
* active modules (such as swrast_setup, swrast, tnl, etc).
*
* Set ctx->NewState to zero to avoid recursion if
* Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?)
*/
new_state = ctx->NewState | new_prog_state;
ctx->NewState = 0;
ctx->Driver.UpdateState(ctx, new_state);
ctx->Array.NewState = 0;
}
/*
* If ctx->NewState is non-zero then this function MUST be called before
* rendering any primitive. Basically, function pointers and miscellaneous
* flags are updated to reflect the current state of the state machine.
*
* The above constraint is now maintained largely by the two Exec
* dispatch tables, which trigger the appropriate flush on transition
* between State and Geometry modes.
*
* Special care is taken with the derived value _NeedEyeCoords. This
* is a bitflag which is updated with information from a number of
* attribute groups (MODELVIEW, LIGHT, TEXTURE). A lot of derived
* state references this value, and must be treated with care to
* ensure that updates are done correctly. All state dependent on
* _NeedEyeCoords is calculated from within _mesa_update_tnl_spaces(),
* and from nowhere else.
*/
void _mesa_update_state( GLcontext *ctx )
{
const GLuint new_state = ctx->NewState;
const GLuint oldneedeyecoords = ctx->_NeedEyeCoords;
if (MESA_VERBOSE & VERBOSE_STATE)
_mesa_print_state("_mesa_update_state", new_state);
if (new_state & _NEW_MODELVIEW)
_math_matrix_analyse( &ctx->ModelView );
if (new_state & _NEW_PROJECTION)
update_projection( ctx );
if (new_state & _NEW_TEXTURE_MATRIX)
update_texture_matrices( ctx );
if (new_state & _NEW_COLOR_MATRIX)
_math_matrix_analyse( &ctx->ColorMatrix );
/* References ColorMatrix.type (derived above).
*/
if (new_state & _IMAGE_NEW_TRANSFER_STATE)
update_image_transfer_state(ctx);
/* Contributes to NeedEyeCoords, NeedNormals.
*/
if (new_state & _NEW_TEXTURE)
update_texture_state( ctx );
if (new_state & (_NEW_BUFFERS|_NEW_SCISSOR))
update_drawbuffer( ctx );
if (new_state & _NEW_POLYGON)
update_polygon( ctx );
/* Contributes to NeedEyeCoords, NeedNormals.
*/
if (new_state & _NEW_LIGHT)
_mesa_update_lighting( ctx );
/* We can light in object space if the modelview matrix preserves
* lengths and relative angles.
*/
if (new_state & (_NEW_MODELVIEW|_NEW_LIGHT)) {
ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT_MODELVIEW;
if (ctx->Light.Enabled &&
!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
ctx->_NeedEyeCoords |= NEED_EYE_LIGHT_MODELVIEW;
}
/* Keep ModelviewProject uptodate always to allow tnl
* implementations that go model->clip even when eye is required.
*/
if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
calculate_model_project_matrix(ctx);
/* ctx->_NeedEyeCoords is now uptodate.
*
* If the truth value of this variable has changed, update for the
* new lighting space and recompute the positions of lights and the
* normal transform.
*
* If the lighting space hasn't changed, may still need to recompute
* light positions & normal transforms for other reasons.
*/
if (new_state & (_NEW_MODELVIEW |
_NEW_LIGHT |
_MESA_NEW_NEED_EYE_COORDS))
update_tnl_spaces( ctx, oldneedeyecoords );
/*
* Here the driver sets up all the ctx->Driver function pointers
* to it's specific, private functions, and performs any
* internal state management necessary, including invalidating
* state of active modules.
*
* Set ctx->NewState to zero to avoid recursion if
* Driver.UpdateState() has to call FLUSH_VERTICES(). (fixed?)
*/
ctx->NewState = 0;
ctx->Driver.UpdateState(ctx, new_state);
ctx->Array.NewState = 0;
/* At this point we can do some assertions to be sure the required
* device driver function pointers are all initialized.
*/
ASSERT(ctx->Driver.GetString);
ASSERT(ctx->Driver.UpdateState);
ASSERT(ctx->Driver.Clear);
ASSERT(ctx->Driver.SetDrawBuffer);
ASSERT(ctx->Driver.GetBufferSize);
if (ctx->Visual.accumRedBits > 0) {
ASSERT(ctx->Driver.Accum);
}
ASSERT(ctx->Driver.DrawPixels);
ASSERT(ctx->Driver.ReadPixels);
ASSERT(ctx->Driver.CopyPixels);
ASSERT(ctx->Driver.Bitmap);
ASSERT(ctx->Driver.ResizeBuffers);
ASSERT(ctx->Driver.TexImage1D);
ASSERT(ctx->Driver.TexImage2D);
ASSERT(ctx->Driver.TexImage3D);
ASSERT(ctx->Driver.TexSubImage1D);
ASSERT(ctx->Driver.TexSubImage2D);
ASSERT(ctx->Driver.TexSubImage3D);
ASSERT(ctx->Driver.CopyTexImage1D);
ASSERT(ctx->Driver.CopyTexImage2D);
ASSERT(ctx->Driver.CopyTexSubImage1D);
ASSERT(ctx->Driver.CopyTexSubImage2D);
ASSERT(ctx->Driver.CopyTexSubImage3D);
if (ctx->Extensions.ARB_texture_compression) {
ASSERT(ctx->Driver.BaseCompressedTexFormat);
ASSERT(ctx->Driver.CompressedTextureSize);
ASSERT(ctx->Driver.GetCompressedTexImage);
#if 0 /* HW drivers need these, but not SW rasterizers */
ASSERT(ctx->Driver.CompressedTexImage1D);
ASSERT(ctx->Driver.CompressedTexImage2D);
ASSERT(ctx->Driver.CompressedTexImage3D);
ASSERT(ctx->Driver.CompressedTexSubImage1D);
ASSERT(ctx->Driver.CompressedTexSubImage2D);
ASSERT(ctx->Driver.CompressedTexSubImage3D);
#endif
}
}
void qtvplugin_geomarker::on_pushButton_QTV_update_clicked()
{
if (m_pVi==0 || !m_pScene)
return;
QString name = ui->lineEdit_QTV_currentID->text();
ini_save();
//Get pen and brush settings
Qt::PenStyle pst [] ={
Qt::NoPen ,
Qt::SolidLine ,
Qt::DashLine ,
Qt::DotLine ,
Qt::DashDotLine ,
Qt::DashDotDotLine ,
Qt::CustomDashLine
};
Qt::BrushStyle bst [] = {
Qt::NoBrush,
Qt::SolidPattern,
Qt::Dense1Pattern,
Qt::Dense2Pattern,
Qt::Dense3Pattern,
Qt::Dense4Pattern,
Qt::Dense5Pattern,
Qt::Dense6Pattern,
Qt::Dense7Pattern,
Qt::HorPattern,
Qt::VerPattern,
Qt::CrossPattern,
Qt::BDiagPattern,
Qt::FDiagPattern,
Qt::DiagCrossPattern
};
int ptdd = ui->comboBox_QTV_linePad->currentIndex();
if (ptdd < 0 || ptdd >=7)
ptdd = 1;
QColor penColor = string2color( ui->lineEdit_QTV_PenColor->text());
int penWidth = ui->spinBox_QTV_penWidth->value();
QPen pen;//(QBrush(color),width,pst[ptdd]);
pen.setColor(penColor);
pen.setWidth(penWidth);
pen.setStyle(pst[ptdd]);
int btdd = ui->comboBox_QTV_fillPad->currentIndex();
if (btdd < 0 || btdd >=15)
btdd = 1;
QColor brushColor = string2color( ui->lineEdit_QTV_FillColor->text());
QBrush brush;
brush.setColor(brushColor);
brush.setStyle(bst[btdd]);
QTVP_GEOMARKER::geoItemBase * newitem = 0;
if (ui->radioButton_QTV_tool_point->isChecked())
{
double lat = ui->lineEdit_QTV_point_lat->text().toDouble();
double lon = ui->lineEdit_QTV_point_lon->text().toDouble();
int tp = ui->radioButton_QTV_PointRect->isChecked()?0:1;
int width = ui->spinBox_QTV_point_width->value();
int height = ui->spinBox_QTV_point_height->value();
if (tp==0)
newitem = update_point<QTVP_GEOMARKER::geoGraphicsRectItem>(name,lat,lon,width,height,pen,brush);
else
newitem = update_point<QTVP_GEOMARKER::geoGraphicsEllipseItem>(name,lat,lon,width,height,pen,brush);
}
else if (ui->radioButton_QTV_tool_line->isChecked())
{
double lat1 = ui->lineEdit_QTV_lineLat1->text().toDouble();
double lat2 = ui->lineEdit_QTV_lineLat2->text().toDouble();
double lon1 = ui->lineEdit_QTV_lineLon1->text().toDouble();
double lon2 = ui->lineEdit_QTV_lineLon2->text().toDouble();
newitem = update_line(name,lat1,lon1,lat2,lon2,pen);
}
else if (ui->radioButton_QTV_tool_polygon->isChecked())
{
QPolygonF latlons;
QString strPlainTexts = ui->plainTextEdit_QTV_corners->toPlainText();
strPlainTexts.remove(' ');
strPlainTexts.remove('\n');
strPlainTexts.remove('\r');
strPlainTexts.remove('\015');
strPlainTexts.remove('\012');
QStringList lst = strPlainTexts.split(QRegExp("[,;]"),QString::SkipEmptyParts);
int c = 0;
QPointF ll;
foreach (QString s,lst)
{
if (c%2==0)
ll.setY(s.toDouble());
else
ll.setX(s.toDouble());
if ((++c) % 2==0)
latlons.push_back(ll);
}
if (latlons.size())
newitem = update_polygon(name,latlons,pen,brush,ui->checkBox_QTV_multiline->isChecked()?true:false);
}
