void reShapeRenderable::draw( int state /*= 0*/, int id /*= 0*/ )
{
if (!state)
{
if (!highlighted)
{
glColor4fv(glm::value_ptr(color));
}
else
{
glColor4fv(glm::value_ptr(reVec4(1,1,0,1)));
}
}
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_CULL_FACE);
drawShape(state, id);
glPopAttrib();
}
void drawObjects(int level, int numits, int curlevel, int curit)
{
//if we leave the bounds of the "tree" start recursing back
if(curlevel >= level || curit >= shapes[curlevel]->iterations)
return;
/* use offsets for subsequent iterations */
if(curit > 0)
{
glTranslatef(shapes[curlevel]->xoff,shapes[curlevel]->yoff, shapes[curlevel]->zoff);
glRotatef(shapes[curlevel]->xroff, 1 , 0, 0);
glRotatef(shapes[curlevel]->yroff, 0 , 1, 0);
glRotatef(shapes[curlevel]->zroff, 0 , 0, 1);
glScalef(shapes[curlevel]->xsoff ,shapes[curlevel]->ysoff, shapes[curlevel]->zsoff);
}
else /*otherwise use initial values */
{
glTranslatef(shapes[curlevel]->inx, shapes[curlevel]->iny, shapes[curlevel]->inz);
glRotatef(shapes[curlevel]->inxr, 1 , 0, 0);
glRotatef(shapes[curlevel]->inyr, 0 , 1, 0);
glRotatef(shapes[curlevel]->inzr, 0 , 0, 1);
glScalef(shapes[curlevel]->inxs ,shapes[curlevel]->inys, shapes[curlevel]->inzs);
}
/* draw the current shape the to the current location as defined in the matrix */
drawShape(shapes[curlevel]);
//go down a level
drawObjects(level, numits, curlevel+1, 0);
//go right an iteration
drawObjects(level, numits, curlevel, curit+1);
}
void ShapeDrawer::drawRigidBody(const btRigidBody* body)
{
glPushMatrix();
loadWorldSpace(body);
glDrawCoordsys();
if(body->getInvMass() < .01f) {
glColor3f(.1f, .2f, .2f);
}
else {
if(body->getActivationState() == 1)
glColor3f(0.f, 1.f, 0.f);
else
glColor3f(0.f, 0.f, 1.f);
}
const btCollisionShape* shape = body->getCollisionShape();
drawShape(shape);
glPopMatrix();
}
void testApp :: drawShapes ()
{
ofEnableSmoothing();
for( int i=0; i<shapes.size(); i++ )
{
// ofFill();
// ofSetColor( 0xFFFFFF );
//
// drawShape( shapes[ i ] );
ofNoFill();
ofSetColor( 0xFF0000 );
drawShape( shapes[ i ] );
}
ofDisableSmoothing();
}
/*
* display()
* ------
* Display the scene
*/
void display()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glLoadIdentity();
/* setup functions */
setEye();
/* draw */
drawAxes();
drawValues();
/* magic here */
drawShape();
glFlush();
glutSwapBuffers();
}
void draw_stroke(caskbench_context_t *ctx, kinetics_t *particles)
{
int i, r,j;
int w, h;
double x,y;
cairo_t *cr = ctx->cairo_cr;
for (j=0; j<num_y_elements; j++) {
y = particles?particles->y : j * element_spacing;
cairo_set_line_join(cr,(cairo_line_join_t)(j % 3));
for (i=0; i<num_x_elements; i++) {
x = particles?particles->x : i * element_spacing;
cairo_set_line_cap(cr,(cairo_line_cap_t)(i % 3));
cairoRandomizeColor(ctx);
drawShape(ctx,x,y);
cairo_stroke (cr);
}
}
}
bool MgShape::draw(int mode, GiGraphics& gs, const GiContext *ctx, int segment) const
{
GiContext tmpctx(context());
if (shapec()->isKindOf(6)) { // MgComposite
tmpctx = ctx ? *ctx : GiContext(0, GiColor(), GiContext::kNullLine);
}
else if (ctx) {
float addw = ctx->getLineWidth();
if (addw < -0.1f) {
tmpctx.setExtraWidth(-addw);
} else if (addw > 0.1f) { // 传入正数表示像素宽度
tmpctx.setLineWidth(-addw, ctx->isAutoScale()); // 换成新的像素宽度
}
if (ctx->getLineColor().a > 0) {
tmpctx.setLineColor(ctx->getLineColor());
}
if (!ctx->isNullLine()) {
tmpctx.setLineStyle(ctx->getLineStyle());
}
if (ctx->hasFillColor()) {
tmpctx.setFillColor(ctx->getFillColor());
}
}
bool ret = false;
Box2d rect(shapec()->getExtent() * gs.xf().modelToDisplay());
rect.inflate(1 + gs.calcPenWidth(tmpctx.getLineWidth(), tmpctx.isAutoScale()) / 2);
if (gs.beginShape(shapec()->getType(), getID(),
(int)shapec()->getChangeCount(),
rect.xmin, rect.ymin, rect.width(), rect.height())) {
ret = drawShape(getParent(), *shapec(), mode, gs, tmpctx, segment);
gs.endShape(shapec()->getType(), getID(), rect.xmin, rect.ymin);
}
return ret;
}
glm::vec2 TextBatch::draw(const LineLayout& _line, size_t _start, size_t _end,
glm::vec2 _position, LineMetrics& _metrics) {
float startX = _position.x;
for (size_t j = _start; j < _end; j++) {
auto& c = _line.shapes()[j];
if (!c.isSpace) {
drawShape(_line.font(), c, _position, _line.scale(), _metrics);
}
_position.x += _line.advance(c);
if (c.mustBreak) {
_position.x = startX;
_position.y += _line.height();
}
}
_position.y += _line.height();
return _position;
}
void ParticleShaderVoronoi::drawParticle(int i)
{
// push the shader name down
glPushName(0xffffffff);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gmVector3 p = position->getPosition(i);
glTranslatef(p[0],p[1],p[2]);
gmMatrix4 rotMat = orientation->getMatrix(i);
GLdouble mat[16];
rotMat.copyTo(mat);
glMultMatrixd(mat);
// Set the disk center
GLfloat dC[3] = {0.0, 0.0, 0.0};
// Get the radius
if (radius_data)
radius = (*radius_data)[i];
else
radius = 1.0;
// Set the per-particle Cg parameters
cgGLSetParameter3fv(diskCenterWC, dC);
cgGLSetParameter1f(diskRadius, GLfloat(radius * scale));
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
drawShape(i);
glPopMatrix();
glPopName();
}
void
CQIllustratorShape::
draw(CQIllustratorShapeDrawer *drawer) const
{
if (getFilter() != 0)
drawGaussian(drawer);
else
drawShape(drawer);
if (getFixed()) {
const CBBox2D &bbox = getFlatBBox();
drawer->pathInit();
drawer->pathMoveTo(bbox.getLL());
drawer->pathLineTo(bbox.getUR());
drawer->pathStroke();
drawer->pathInit();
drawer->pathMoveTo(bbox.getLR());
drawer->pathLineTo(bbox.getUL());
drawer->pathStroke();
}
}
//! [5]
void RenderArea::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.fillRect(event->rect(), QBrush(Qt::white));
painter.translate(66, 66);
//! [5]
//! [6]
painter.save();
transformPainter(painter);
drawShape(painter);
painter.restore();
//! [6]
//! [7]
drawOutline(painter);
//! [7]
//! [8]
transformPainter(painter);
drawCoordinates(painter);
}
void drawCone(void) {
drawShape(&coneData);
}
void Tesselate_Presentation::tesselateShape(const TopoDS_Shape& aShape)
{
// setResultTitle("Tesselate shape");
TCollection_AsciiString aText = (
"/////////////////////////////////////////////////////////////////" EOL
"// Tesselate shape." EOL
"/////////////////////////////////////////////////////////////////" EOL EOL
) ;
Standard_Real aDeflection = DATA[myIndex][0];
Standard_Integer aNumOfFace = (Standard_Integer)DATA[myIndex][1];
Standard_Integer aNumOfEdge = (Standard_Integer)DATA[myIndex][2];
aText +=
"Standard_Real aDeflection;" EOL
"// aDeflection = ... ;" EOL EOL
"// removes all the triangulations of the faces ," EOL
"//and all the polygons on the triangulations of the edges:" EOL
"BRepTools::Clean(aShape);" EOL EOL
"// adds a triangulation of the shape aShape with the deflection aDeflection:" EOL
"BRepMesh::Mesh(aShape,aDeflection);" EOL EOL
"TopExp_Explorer aExpFace,aExpEdge;" EOL
"for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())" EOL
"{ " EOL
" TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());" EOL
" TopLoc_Location aLocation;" EOL EOL
" // takes the triangulation of the face aFace:" EOL
" Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);" EOL EOL
" if(!aTr.IsNull()) // if this triangulation is not NULL" EOL
" { " EOL
" // takes the array of nodes for this triangulation:" EOL
" const TColgp_Array1OfPnt& aNodes = aTr->Nodes();" EOL
" // takes the array of triangles for this triangulation:" EOL
" const Poly_Array1OfTriangle& triangles = aTr->Triangles();" EOL EOL
" // create array of node points in absolute coordinate system" EOL
" TColgp_Array1OfPnt aPoints(1, aNodes.Length());" EOL
" for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)" EOL
" aPoints(i) = aNodes(i).Transformed(aLocation);" EOL EOL
" // Takes the node points of each triangle of this triangulation." EOL
" // takes a number of triangles:" EOL
" Standard_Integer nnn = aTr->NbTriangles();" EOL
" Standard_Integer nt,n1,n2,n3;" EOL
" for( nt = 1 ; nt < nnn+1 ; nt++)" EOL
" {" EOL
" // takes the node indices of each triangle in n1,n2,n3:" EOL
" triangles(nt).Get(n1,n2,n3);" EOL
" // takes the node points:" EOL
" gp_Pnt aPnt1 = aPoints(n1);" EOL
" gp_Pnt aPnt2 = aPoints(n2);" EOL
" gp_Pnt aPnt3 = aPoints(n3);" EOL
" } " EOL EOL
" // Takes the polygon associated to an edge." EOL
" aExpEdge.Init(aFace,TopAbs_EDGE);" EOL
" TopoDS_Edge aEdge;" EOL
" // for example,working with the first edge:" EOL
" if(aExpEdge.More())" EOL
" aEdge = TopoDS::Edge(aExpEdge.Current());" EOL EOL
" if(!aEdge.IsNull()) // if this edge is not NULL" EOL
" {" EOL
" // takes the polygon associated to the edge aEdge:" EOL
" Handle_Poly_PolygonOnTriangulation aPol = " EOL
" BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());" EOL EOL
" if(!aPol.IsNull()) // if this polygon is not NULL" EOL
" // takes the array of nodes for this polygon" EOL
" // (indexes in the array of nodes for triangulation of theFace):" EOL
" const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();" EOL
" }" EOL
" }" EOL
"}" EOL EOL
"//==================================================" EOL EOL
;
aText += " Result with deflection = ";
aText += TCollection_AsciiString(aDeflection);
aText += " :" EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
//==========================================================================
BRepTools::Clean(aShape);
BRepMesh::Mesh(aShape,aDeflection);
BRep_Builder aBuilder,aBuild1,aBuild2;
TopoDS_Compound aCompound,aComp1,aComp2;
aBuilder.MakeCompound(aCompound);
aBuild1.MakeCompound(aComp1);
aBuild2.MakeCompound(aComp2);
TopTools_SequenceOfShape aVertices;
Standard_Integer aCount = 0;
Standard_Integer aNumOfNodes = 0;
Standard_Integer aNumOfTriangles = 0;
Handle_AIS_InteractiveObject aShowEdge,aShowFace,aShowShape;
TopExp_Explorer aExpFace,aExpEdge;
for(aExpFace.Init(aShape,TopAbs_FACE);aExpFace.More();aExpFace.Next())
{
aCount++;
TopoDS_Face aFace = TopoDS::Face(aExpFace.Current());
TopLoc_Location aLocation;
Handle_Poly_Triangulation aTr = BRep_Tool::Triangulation(aFace,aLocation);
if(!aTr.IsNull())
{
const TColgp_Array1OfPnt& aNodes = aTr->Nodes();
aNumOfNodes += aTr->NbNodes();
Standard_Integer aLower = aNodes.Lower();
Standard_Integer anUpper = aNodes.Upper();
const Poly_Array1OfTriangle& triangles = aTr->Triangles();
aNumOfTriangles += aTr->NbTriangles();
if(aCount == aNumOfFace)
{
Standard_Integer aNbOfNodesOfFace = aTr->NbNodes();
Standard_Integer aNbOfTrianglesOfFace = aTr->NbTriangles();
aExpEdge.Init(aFace,TopAbs_EDGE);
TopoDS_Edge aEdge;
for( Standard_Integer i = 0; aExpEdge.More() && i < aNumOfEdge ; aExpEdge.Next(), i++)
aEdge = TopoDS::Edge(aExpEdge.Current());
if(!aEdge.IsNull())
{
Handle_Poly_PolygonOnTriangulation aPol =
BRep_Tool::PolygonOnTriangulation(aEdge,aTr,aEdge.Location());
if(!aPol.IsNull())
{
const TColStd_Array1OfInteger& aNodesOfPol = aPol->Nodes();
Standard_Integer aNbOfNodesOfEdge = aPol->NbNodes();
aText += "Number of nodes of the edge = ";
aText += TCollection_AsciiString(aNbOfNodesOfEdge) + EOL;
aText += "Number of nodes of the face = ";
aText += TCollection_AsciiString(aNbOfNodesOfFace) + EOL;
aText += "Number of triangles of the face = ";
aText += TCollection_AsciiString(aNbOfTrianglesOfFace) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
Standard_Integer aLower = aNodesOfPol.Lower(), anUpper = aNodesOfPol.Upper();
for( int i = aLower; i < anUpper ; i++)
{
gp_Pnt aPnt1 = aNodes(aNodesOfPol(i)).Transformed(aLocation);
gp_Pnt aPnt2 = aNodes(aNodesOfPol(i+1)).Transformed(aLocation);
TopoDS_Vertex aVertex1 = BRepBuilderAPI_MakeVertex (aPnt1);
TopoDS_Vertex aVertex2 = BRepBuilderAPI_MakeVertex (aPnt2);
if(!aVertex1.IsNull() && !aVertex2.IsNull() && // if vertices are "alive"
!BRep_Tool::Pnt(aVertex1).IsEqual(
BRep_Tool::Pnt(aVertex2),Precision::Confusion())) // if they are different
{
aEdge = BRepBuilderAPI_MakeEdge (aVertex1,aVertex2);
aBuild2.Add(aComp2,aVertex1);
if(!aEdge.IsNull())
aBuild2.Add(aComp2,aEdge);
if(i == anUpper-1)
aBuild2.Add(aComp2,aVertex2);
}
}
getAISContext()->EraseAll();
aShowShape = drawShape(aShape);
if(WAIT_A_SECOND) return;
aShowEdge = drawShape(aComp2,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowShape);
if(WAIT_A_SECOND) return;
}
}
}
TopTools_DataMapOfIntegerShape aEdges;
TopTools_SequenceOfShape aVertices;
for( Standard_Integer i = 1; i < aNodes.Length()+1; i++)
{
gp_Pnt aPnt = aNodes(i).Transformed(aLocation);
TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex(aPnt);
if(!aVertex.IsNull())
{
aBuilder.Add(aCompound,aVertex);
if(aCount == aNumOfFace )
aBuild1.Add(aComp1,aVertex);
aVertices.Append(aVertex);
}
}
Standard_Integer nnn = aTr->NbTriangles();
Standard_Integer nt,n1,n2,n3;
for( nt = 1 ; nt < nnn+1 ; nt++)
{
triangles(nt).Get(n1,n2,n3);
Standard_Integer key[3];
TopoDS_Vertex aV1,aV2;
key[0] = _key(n1, n2);
if(!aEdges.IsBound(key[0]))
{
aV1 = TopoDS::Vertex(aVertices(n1));
aV2 = TopoDS::Vertex(aVertices(n2));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[0], aEdge);
aBuilder.Add(aCompound,aEdges(key[0]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[0]));
}
}
}
key[1] = _key(n2,n3);
if(!aEdges.IsBound(key[1]))
{
aV1 = TopoDS::Vertex(aVertices(n2));
aV2 = TopoDS::Vertex(aVertices(n3));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[1],aEdge);
aBuilder.Add(aCompound,aEdges(key[1]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[1]));
}
}
}
key[2] = _key(n3,n1);
if(!aEdges.IsBound(key[2]))
{
aV1 = TopoDS::Vertex(aVertices(n3));
aV2 = TopoDS::Vertex(aVertices(n1));
if(!aV1.IsNull() && !aV2.IsNull() &&
!BRep_Tool::Pnt(aV1).IsEqual(BRep_Tool::Pnt(aV2),Precision::Confusion()))
{
TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge (aV1,aV2);
if(!aEdge.IsNull())
{
aEdges.Bind(key[2],aEdge);
aBuilder.Add(aCompound,aEdges(key[2]));
if(aCount == aNumOfFace)
aBuild1.Add(aComp1,aEdges(key[2]));
}
}
}
}
if(aCount == aNumOfFace)
{
aShowFace = drawShape(aComp1,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowEdge);
}
}
else
{
aText += "Can't compute a triangulation on face ";
aText += TCollection_AsciiString(aCount) + EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
}
}
aText += "Number of nodes of the shape = ";
aText += TCollection_AsciiString(aNumOfNodes) + EOL;
aText += "Number of triangles of the shape = ";
aText += TCollection_AsciiString(aNumOfTriangles) + EOL EOL;
GetDocument()->PocessTextInDialog("Compute the triangulation on a shape", aText);
// setResultText(aText.ToCString());
if(WAIT_A_SECOND) return;
drawShape(aCompound,Quantity_NOC_GREEN);
getAISContext()->Erase(aShowFace);
}
void Blob::draw() {
ofPushStyle();
ofSetColor(0,0,0, 55);
drawShape();
ofPopStyle();
}
void ofxShapes :: drawSelectedShapeFill( ofxShapesItem *shape )
{
ofFill();
ofSetColor( 200, 200, 200 );
drawShape( shape );
}
void ofxShapes :: drawSelectedShapeStroke( ofxShapesItem *shape )
{
ofNoFill();
ofSetColor( 0, 0, 255 );
drawShape( shape );
}
void Rectangle::drawShape() const
{
drawShape(width, height);
}
void Orbit::draw() {
ofPushStyle(); //for safety in terms of drawing, and not messing up anyone elses code
ofBackground(0); //set to black (0 brightness)
ofFill();
int colorIndex = Settings::getInstance()->settings["fgColor"];
if(colorIndex==20) {
ofSetHexColor(0xFFFFFF);
} else {
ofSetHexColor(ColorPicker::colors[colorIndex]);
}
switch (mode) {
case 0:
if (shapeOnScreen) {
drawShape(currentShapeType, centreOfBigShape, bigShapeRadius); //using the new MagicShapes.h file
}
break;
case 1:
if(numberOfShapes > 0){
if(colorIndex==20) {
ofSetColor(shapesColour);
} else {
ofSetHexColor(ColorPicker::colors[colorIndex]);
}
ofVec2f currentShapePosition = startOfShapes;
for(int i=0; i< numberOfShapes; i++){
drawShape(currentShapeType, currentShapePosition, shapesRadius);
currentShapePosition = currentShapePosition.getRotatedRad(radiansPerShape, centreOfBigShape);
}
}else{
if(colorIndex==20) {
ofSetColor(bigShapeColour);
} else {
ofSetHexColor(ColorPicker::colors[colorIndex]);
}
drawShape(currentShapeType, centreOfBigShape, bigShapeRadius);
}
break;
case 2:
if(numberOfShapes > 0){
if(colorIndex==20) {
ofSetColor(shapesColour);
} else {
ofSetHexColor(ColorPicker::colors[colorIndex]);
}
ofVec2f currentShapePosition = startOfShapes;
for(int i=0; i< numberOfShapes; i++){
drawShape(currentShapeType, currentShapePosition, shapesRadius);
currentShapePosition = currentShapePosition.getRotatedRad(radiansPerShape, centreOfBigShape);
}
if(numberOfMiddleShapes > 0){
currentShapePosition = startOfMiddleShapes;
for(int i=0; i< numberOfMiddleShapes; i++){
drawShape(currentShapeType, currentShapePosition, shapesRadius);
currentShapePosition = currentShapePosition.getRotatedRad(radiansPerMiddleShape, centreOfBigShape);
}
}
if(numberOfInnerShapes > 0){
currentShapePosition = startOfInnerShapes;
for(int i=0; i< numberOfInnerShapes; i++){
drawShape(currentShapeType, currentShapePosition, shapesRadius);
currentShapePosition = currentShapePosition.getRotatedRad(radiansPerInnerShape, centreOfBigShape);
}
}
}else{
if(colorIndex==20) {
ofSetColor(bigShapeColour);
} else {
ofSetHexColor(ColorPicker::colors[colorIndex]);
}
drawShape(currentShapeType, centreOfBigShape, bigShapeRadius);
}
break; //nothing for the most complicated version yet...
default:
break;
}
ofPopStyle(); //pop back what was there before
}
/*
* Implementation of move
*/
void moveShape(Shape *s, int x, int y) {
eraseShape( s );
s->x_pos = x;
s->y_pos = y;
drawShape( s );
}
void drawCylinder(void) {
drawShape(&cylData);
}
void shape::draw(bool selected)
{
//Ensure we're in the correct mode for drawing
glMatrixMode(GL_MODELVIEW);
//In order to translate only this shape, we need to push and pop the current matrix
glPushMatrix();
//Translate the shape so that its centre is in the right location
glTranslated(mXCentre, mYCentre, 0.0);
// glPushMatrix();
//glPushMatrix();
QMatrix4x4 myMat4(myMat);
glMultTransposeMatrixf(myMat4.data());
//glPopMatrix();
//glPopMatrix();
//This might be a good place to add other transformations
//(Here's an example, the identity matrix)
/*
GLdouble matrix[4][4];
matrix[0][0] = 1;
matrix[0][1] = 0;
matrix[0][2] = 0;
matrix[0][3] = 0;
matrix[1][0] = 0;
matrix[1][1] = 1;
matrix[1][2] = 0;
matrix[1][3] = 0;
matrix[2][0] = 0;
matrix[2][1] = 0;
matrix[2][2] = 1;
matrix[2][3] = 0;
matrix[3][0] = 0;
matrix[3][1] = 0;
matrix[3][2] = 0;
matrix[3][3] = 1;
glMultMatrixd(&matrix[0][0]);
*/
//Set the colour
glColor3f(mNormalColour.redF(), mNormalColour.greenF(), mNormalColour.blueF());
//Draw the actual shape
glBegin(GL_POLYGON);
drawShape();
glEnd();
//If it's selected, draw a highlight
if(selected)
{
glColor3f(mSelectedColour.redF(), mSelectedColour.greenF(), mSelectedColour.blueF());
const float lineWidth = 3.0;
glLineWidth(lineWidth);
glBegin(GL_LINE_LOOP);
drawShape();
glEnd();
}
//Restore the original matrix
glPopMatrix();
}
//--------------------------------------------------------------------
// render()
//--------------------------------------------------------------------
U32 LLViewerJoint::render( F32 pixelArea, BOOL first_pass, BOOL is_dummy )
{
stop_glerror();
U32 triangle_count = 0;
//----------------------------------------------------------------
// ignore invisible objects
//----------------------------------------------------------------
if ( mValid )
{
//----------------------------------------------------------------
// if object is transparent, defer it, otherwise
// give the joint subclass a chance to draw itself
//----------------------------------------------------------------
if ( is_dummy )
{
triangle_count += drawShape( pixelArea, first_pass, is_dummy );
}
else if (LLPipeline::sShadowRender)
{
triangle_count += drawShape(pixelArea, first_pass, is_dummy );
}
else if ( isTransparent() && !LLPipeline::sReflectionRender)
{
// Hair and Skirt
if ((pixelArea > MIN_PIXEL_AREA_3PASS_HAIR))
{
// render all three passes
LLGLDisable cull(GL_CULL_FACE);
// first pass renders without writing to the z buffer
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
triangle_count += drawShape( pixelArea, first_pass, is_dummy );
}
// second pass writes to z buffer only
gGL.setColorMask(false, false);
{
triangle_count += drawShape( pixelArea, FALSE, is_dummy );
}
// third past respects z buffer and writes color
gGL.setColorMask(true, false);
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
triangle_count += drawShape( pixelArea, FALSE, is_dummy );
}
}
else
{
// Render Inside (no Z buffer write)
glCullFace(GL_FRONT);
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
triangle_count += drawShape( pixelArea, first_pass, is_dummy );
}
// Render Outside (write to the Z buffer)
glCullFace(GL_BACK);
{
triangle_count += drawShape( pixelArea, FALSE, is_dummy );
}
}
}
else
{
// set up render state
triangle_count += drawShape( pixelArea, first_pass );
}
}
//----------------------------------------------------------------
// render children
//----------------------------------------------------------------
for (child_list_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
{
LLViewerJoint* joint = (LLViewerJoint*)(*iter);
F32 jointLOD = joint->getLOD();
if (pixelArea >= jointLOD || sDisableLOD)
{
triangle_count += joint->render( pixelArea, TRUE, is_dummy );
if (jointLOD != DEFAULT_LOD)
{
break;
}
}
}
return triangle_count;
}
// this is able to handle multiple weapon graphics now
// removed mountRotation,they get such stuff from psObj directly now
static bool displayCompObj(DROID *psDroid, bool bButton, const glm::mat4 &viewMatrix)
{
iIMDShape *psMoveAnim, *psStillAnim;
SDWORD iConnector;
PROPULSION_STATS *psPropStats;
SDWORD pieFlag, iPieData;
PIELIGHT brightness;
UDWORD colour;
UBYTE i;
bool didDrawSomething = false;
glm::mat4 modelMatrix(1.f);
if (graphicsTime - psDroid->timeLastHit < GAME_TICKS_PER_SEC / 4 && psDroid->lastHitWeapon == WSC_ELECTRONIC && !gamePaused())
{
colour = getPlayerColour(rand() % MAX_PLAYERS);
}
else
{
colour = getPlayerColour(psDroid->player);
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(didDrawSomething, psPropStats != nullptr, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
if (bButton)
{
pieFlag = pie_BUTTON;
brightness = WZCOL_WHITE;
}
else
{
pieFlag = pie_SHADOW;
brightness = pal_SetBrightness(psDroid->illumination);
// NOTE: Beware of transporters that are offscreen, on a mission! We should *not* be checking tiles at this point in time!
if (!isTransporter(psDroid) && !missionIsOffworld())
{
MAPTILE *psTile = worldTile(psDroid->pos.x, psDroid->pos.y);
if (psTile->jammerBits & alliancebits[psDroid->player])
{
pieFlag |= pie_ECM;
}
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
iPieData = 0;
}
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_PROPELLOR)
{
// FIXME: change when adding submarines to the game
modelMatrix *= glm::translate(glm::vec3(0.f, -world_coord(1) / 2.3f, 0.f));
}
iIMDShape *psShapeProp = (leftFirst ? getLeftPropulsionIMD(psDroid) : getRightPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewMatrix * modelMatrix))
{
didDrawSomething = true;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_BODY] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
/* Get the body graphic now*/
iIMDShape *psShapeBody = BODY_IMD(psDroid, psDroid->player);
if (psShapeBody)
{
iIMDShape *strImd = psShapeBody;
if (psDroid->droidType == DROID_PERSON)
{
modelMatrix *= glm::scale(glm::vec3(.75f)); // FIXME - hideous....!!!!
}
if (strImd->objanimpie[psDroid->animationEvent])
{
strImd = psShapeBody->objanimpie[psDroid->animationEvent];
}
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
while (strImd)
{
if (drawShape(psDroid, strImd, colour, brightness, pieFlag, iPieData, viewModelMatrix))
{
didDrawSomething = true;
}
strImd = strImd->next;
}
}
/* Render animation effects based on movement or lack thereof, if any */
psMoveAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppMoveIMDList[psDroid->asBits[COMP_PROPULSION]];
psStillAnim = asBodyStats[psDroid->asBits[COMP_BODY]].ppStillIMDList[psDroid->asBits[COMP_PROPULSION]];
glm::mat4 viewModelMatrix = viewMatrix * modelMatrix;
if (!bButton && psMoveAnim && psDroid->sMove.Status != MOVEINACTIVE)
{
if (pie_Draw3DShape(psMoveAnim, getModularScaledGraphicsTime(psMoveAnim->animInterval, psMoveAnim->numFrames), colour, brightness, pie_ADDITIVE, 200, viewModelMatrix))
{
didDrawSomething = true;
}
}
else if (!bButton && psStillAnim) // standing still
{
if (pie_Draw3DShape(psStillAnim, getModularScaledGraphicsTime(psStillAnim->animInterval, psStillAnim->numFrames), colour, brightness, 0, 0, viewModelMatrix))
{
didDrawSomething = true;
}
}
//don't change the screen coords of an object if drawing it in a button
if (!bButton)
{
/* set up all the screen coords stuff - need to REMOVE FROM THIS LOOP */
calcScreenCoords(psDroid, viewModelMatrix);
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR] == 0 &&
psDroid->asBits[COMP_ECM] == 0 &&
psDroid->asBits[COMP_BRAIN] == 0 &&
psDroid->asBits[COMP_REPAIRUNIT] == 0 &&
psDroid->asBits[COMP_CONSTRUCT] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
if (psShapeBody && psShapeBody->nconnectors)
{
/* vtol weapons attach to connector 2 (underneath);
* all others to connector 1 */
/* VTOL's now skip the first 5 connectors(0 to 4),
VTOL's use 5,6,7,8 etc now */
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT && psDroid->droidType == DROID_WEAPON)
{
iConnector = VTOL_CONNECTOR_START;
}
else
{
iConnector = 0;
}
switch (psDroid->droidType)
{
case DROID_DEFAULT:
case DROID_TRANSPORTER:
case DROID_SUPERTRANSPORTER:
case DROID_CYBORG:
case DROID_CYBORG_SUPER:
case DROID_WEAPON:
case DROID_COMMAND: // command droids have a weapon to store all the graphics
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
/* Double check that the weapon droid actually has any */
for (i = 0; i < psDroid->numWeaps; i++)
{
if ((psDroid->asWeaps[i].nStat > 0 || psDroid->droidType == DROID_DEFAULT)
&& psShapeBody->connectors)
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, i, graphicsTime);
glm::mat4 localModelMatrix = modelMatrix;
//to skip number of VTOL_CONNECTOR_START ground unit connectors
if (iConnector < VTOL_CONNECTOR_START)
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[i].xzy()));
}
else
{
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[iConnector + i].xzy()));
}
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
/* Get the mount graphic */
iIMDShape *psShape = WEAPON_MOUNT_IMD(psDroid, i);
int recoilValue = getRecoil(psDroid->asWeaps[i]);
localModelMatrix *= glm::translate(glm::vec3(0.f, 0.f, recoilValue / 3.f));
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
localModelMatrix *= glm::translate(glm::vec3(0, 0, recoilValue));
/* translate for weapon mount point */
if (psShape && psShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors->xzy()));
}
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//pitch the barrel down
localModelMatrix *= glm::rotate(UNDEG(-rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
else
{
//pitch the barrel up
localModelMatrix *= glm::rotate(UNDEG(rot.pitch), glm::vec3(1.f, 0.f, 0.f));
}
/* Get the weapon (gun?) graphic */
psShape = WEAPON_IMD(psDroid, i);
// We have a weapon so we draw it and a muzzle flash from weapon connector
if (psShape)
{
glm::mat4 localViewModelMatrix = viewMatrix * localModelMatrix;
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, localViewModelMatrix))
{
didDrawSomething = true;
}
drawMuzzleFlash(psDroid->asWeaps[i], psShape, MUZZLE_FLASH_PIE(psDroid, i), brightness, pieFlag, iPieData, localViewModelMatrix);
}
}
}
break;
case DROID_SENSOR:
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
case DROID_ECM:
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
{
Rotation rot = getInterpolatedWeaponRotation(psDroid, 0, graphicsTime);
iIMDShape *psShape = nullptr;
iIMDShape *psMountShape = nullptr;
switch (psDroid->droidType)
{
default:
ASSERT(false, "Bad component type");
break;
case DROID_SENSOR:
psMountShape = SENSOR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the sensor graphic, assuming it's there */
psShape = SENSOR_IMD(psDroid, psDroid->player);
break;
case DROID_CONSTRUCT:
case DROID_CYBORG_CONSTRUCT:
psMountShape = CONSTRUCT_MOUNT_IMD(psDroid, psDroid->player);
/* Get the construct graphic assuming it's there */
psShape = CONSTRUCT_IMD(psDroid, psDroid->player);
break;
case DROID_ECM:
psMountShape = ECM_MOUNT_IMD(psDroid, psDroid->player);
/* Get the ECM graphic assuming it's there.... */
psShape = ECM_IMD(psDroid, psDroid->player);
break;
case DROID_REPAIR:
case DROID_CYBORG_REPAIR:
psMountShape = REPAIR_MOUNT_IMD(psDroid, psDroid->player);
/* Get the Repair graphic assuming it's there.... */
psShape = REPAIR_IMD(psDroid, psDroid->player);
break;
}
/* Get the mounting graphic - we've already moved to the right position
Allegedly - all droids will have a mount graphic so this shouldn't
fall on it's arse......*/
//sensor and cyborg and ecm uses connectors[0]
glm::mat4 localModelMatrix = modelMatrix;
/* vtol weapons inverted */
if (iConnector >= VTOL_CONNECTOR_START)
{
//this might affect gun rotation
localModelMatrix *= glm::rotate(UNDEG(65536 / 2), glm::vec3(0.f, 0.f, 1.f));
}
localModelMatrix *= glm::translate(glm::vec3(psShapeBody->connectors[0].xzy()));
localModelMatrix *= glm::rotate(UNDEG(-rot.direction), glm::vec3(0.f, 1.f, 0.f));
/* Draw it */
if (psMountShape)
{
if (pie_Draw3DShape(psMountShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
}
/* translate for construct mount point if cyborg */
if (cyborgDroid(psDroid) && psMountShape && psMountShape->nconnectors)
{
localModelMatrix *= glm::translate(glm::vec3(psMountShape->connectors[0].xzy()));
}
/* Draw it */
if (psShape)
{
if (pie_Draw3DShape(psShape, 0, colour, brightness, pieFlag, iPieData, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// In repair droid case only:
if ((psDroid->droidType == DROID_REPAIR || psDroid->droidType == DROID_CYBORG_REPAIR) &&
psShape->nconnectors && psDroid->action == DACTION_DROIDREPAIR)
{
Spacetime st = interpolateObjectSpacetime(psDroid, graphicsTime);
localModelMatrix *= glm::translate(glm::vec3(psShape->connectors[0].xzy()));
localModelMatrix *= glm::translate(glm::vec3(0.f, -20.f, 0.f));
psShape = getImdFromIndex(MI_FLAME);
/* Rotate for droid */
localModelMatrix *= glm::rotate(UNDEG(st.rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.pitch), glm::vec3(1.f, 0.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-st.rot.roll), glm::vec3(0.f, 0.f, 1.f));
//rotate Y
localModelMatrix *= glm::rotate(UNDEG(rot.direction), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.y), glm::vec3(0.f, 1.f, 0.f));
localModelMatrix *= glm::rotate(UNDEG(-player.r.x), glm::vec3(1.f, 0.f, 0.f));
if (pie_Draw3DShape(psShape, getModularScaledGraphicsTime(psShape->animInterval, psShape->numFrames), 0, brightness, pie_ADDITIVE, 140, viewMatrix * localModelMatrix))
{
didDrawSomething = true;
}
// localModelMatrix *= glm::rotate(UNDEG(player.r.x), glm::vec3(1.f, 0.f, 0.f)); // Not used?
// localModelMatrix *= glm::rotate(UNDEG(player.r.y), glm::vec3(0.f, 1.f, 0.f)); // Not used?
}
}
break;
}
case DROID_PERSON:
// no extra mounts for people
break;
default:
ASSERT(!"invalid droid type", "Whoa! Weirdy type of droid found in drawComponentObject!!!");
break;
}
}
/* set default components transparent */
if (psDroid->asBits[COMP_PROPULSION] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
}
else
{
pieFlag &= ~pie_TRANSLUCENT;
iPieData = 0;
}
// now render the other propulsion side
psShapeProp = (leftFirst ? getRightPropulsionIMD(psDroid) : getLeftPropulsionIMD(psDroid));
if (psShapeProp)
{
if (pie_Draw3DShape(psShapeProp, 0, colour, brightness, pieFlag, iPieData, viewModelMatrix)) // Safe to use viewModelMatrix because modelView has not been changed since it was calculated
{
didDrawSomething = true;
}
}
return didDrawSomething;
}
void drawCube(void) {
drawShape(&cubeData);
}
void drawSphere(void) {
drawShape(&sphereData);
}
//================================================================
// Function : TexturesExt_Presentation::sampleKitchen
// Purpose : kitchen with texturized items in it.
//================================================================
void TexturesExt_Presentation::sampleKitchen()
{
TopoDS_Shape aShape;
if (!loadShape(aShape, "Kitchen\\Room.brep"))
return;
gp_Trsf aTrsf;
gp_Ax3 NewCoordSystem (gp_Pnt(-1,-1, -1),gp_Dir(0,0,1));
gp_Ax3 CurrentCoordSystem(gp_Pnt(0,0,0),gp_Dir(0,0,1));
aTrsf.SetDisplacement(CurrentCoordSystem, NewCoordSystem);
aShape.Location(TopLoc_Location(aTrsf));
moveScale(aShape);
// draw kitchen room whithout one wall (to better see the insides)
TopTools_IndexedMapOfShape aFaces;
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
Standard_Integer nbFaces = aFaces.Extent();
// create a wooden kitchen floor
// the floor's face will be textured with texture from chataignier.gif
DISP(Texturize(aFaces(5),"plancher.gif",1,1,2,1));
// texturize other faces of the room with texture from wallpaper.gif (walls)
DISP(Texturize(aFaces(1),"wallpaper.gif",1,1,8,6));
DISP(Texturize(aFaces(3),"wallpaper.gif",1,1,8,6));
DISP(Texturize(aFaces(4),"wallpaper.gif",1,1,8,6));
// DISP(drawShape(aFaces(1), Quantity_NOC_LIGHTPINK, Standard_False));
// DISP(drawShape(aFaces(3), Quantity_NOC_LIGHTPINK, Standard_False));
// DISP(drawShape(aFaces(4), Quantity_NOC_LIGHTPINK, Standard_False));
// texturize furniture items with "wooden" texture
if (loadShape(aShape, "Kitchen\\MODERN_Table_1.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Chair_1.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Cooker_1.brep"))
{
moveScale(aShape);
aFaces.Clear();
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
nbFaces = aFaces.Extent();
for (Standard_Integer i = 1; i <= nbFaces; i++)
{
if (i >= 59)
DISP(drawShape(aFaces(i), Graphic3d_NOM_STEEL, Standard_False));
else if (i >= 29)
DISP(drawShape(aFaces(i), Graphic3d_NOM_ALUMINIUM, Standard_False));
else if (i == 28)
DISP(Texturize(aFaces(i), "cookerplate.gif"));
else
DISP(Texturize(aFaces(i), "chataignier.gif"));
}
}
if (loadShape(aShape, "Kitchen\\MODERN_Cooker_1_opened.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Exhaust_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_STONE, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_MVCooker_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_SILVER, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_MVCooker_1_opened.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_SILVER, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_Sink_1.brep"))
{
moveScale(aShape);
aFaces.Clear();
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
nbFaces = aFaces.Extent();
for (Standard_Integer i = 1; i <= nbFaces; i++)
{
if (i < 145)
DISP(drawShape(aFaces(i), Graphic3d_NOM_ALUMINIUM, Standard_False));
else if (i == 145)
DISP(Texturize(aFaces(i), "cookerplate.gif"));
else
DISP(Texturize(aFaces(i), "chataignier.gif"));
}
}
if (loadShape(aShape, "Kitchen\\MODERN_Sink_1_opened.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Refrigerator_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_CHROME, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_Refrigerator_1_opened.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_CHROME, Standard_False));
}
getViewer()->Update();
}
void ScreenWidget::paintGL(){
glClear(GL_COLOR_BUFFER_BIT);
drawShape();
}
