canobj3d.cpp

Go to the documentation of this file.

/*! \file canextobj/src/canobj3d.cpp
    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: canobj3d.cpp,v 1.31 2008/07/19 18:29:43 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include <wx/wfstream.h>
#include <math.h>

#include "wx/canextobj/canobj3d.h"

#include "wx/canvas/candoc.h"
#include "wx/canvas/polygon.h"
#include "wx/canvas/drawer.h"

//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------

IMPLEMENT_CLASS(a2d3DShape, a2dCanvasObject)

#define CIRCLE_STEPS 128

//----------------------------------------------------------------------------
// a2d3DShape
//----------------------------------------------------------------------------

a2d3DShape::a2d3DShape( a2dCanvasObject* toshadow, double depth, double angle ): a2dCanvasObject()
{
    m_shape = toshadow;

    SetFill( *a2dBLACK_FILL );
    SetStroke( *a2dBLACK_STROKE );
    m_depth = depth;
    m_angle3d  = wxDegToRad(angle);
}

a2d3DShape::~a2d3DShape()
{
}

a2d3DShape::a2d3DShape( const a2d3DShape &other, CloneOptions options )
    :a2dCanvasObject( other, options )
{
    m_depth = other.m_depth;
    m_angle3d = other.m_angle3d;
    m_shape=other.m_shape;
}

a2dObject* a2d3DShape::Clone( CloneOptions options ) const 
{
    return new a2d3DShape( *this, options );
};

void a2d3DShape::SetExtrudeFillFromShape()
{
    SetFill( m_shape->GetFill() );
    SetPending(true);
}
void a2d3DShape::SetExtrudeStrokeFromShape()
{
    SetStroke( m_shape->GetStroke() );
    SetPending(true);
}

void a2d3DShape::DoWalker( wxObject *parent, a2dWalkerIOHandler& handler )
{
    a2dCanvasObject::DoWalker( parent, handler );
    if (m_shape)
        m_shape->Walker( this, handler );
}

bool a2d3DShape::DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox )
{
    bool calc=false;
    //the object does not have to be part of a group
    //calculate boundingbox here AND in group
    //since we do not know which one is reached first
    if ( m_shape->GetCanvasDocument()==m_root ) //only if part of this root
    {
        calc=m_shape->Update( mode );
        if ( ( mode & updatemask_force ) || calc || !m_bbox.GetValid() )
        {
            m_bbox.SetValid(false);
            m_bbox.Expand( m_shape->GetMappedBbox(m_lworld) );

            a2dAffineMatrix tworld = m_lworld;
            tworld.Translate( cos(m_angle3d)*m_depth, sin(m_angle3d)*m_depth );
            m_bbox.Expand( m_shape->GetMappedBbox(tworld) );

            calc=true;
        }
    }

    return calc;
}

void a2d3DShape::DoRender( a2dIterC& ic, OVERLAP WXUNUSED(clipparent) )
{
    a2dAffineMatrix inverse =  m_lworld;
    inverse.Invert();

    a2dAffineMatrix tworld = ic.GetTransform();
    tworld *= inverse;

    a2dRectC* rec = wxDynamicCast( m_shape.Get(), a2dRectC);
    if ( rec )
    {
        a2dVertexArray* cpoints = new a2dVertexArray;
        a2dAffineMatrix tworld = ic.GetTransform();
        tworld *= m_shape->GetTransformMatrix();

        //here the Drawer gets a new relative transform
        //Every call for drawing something on it, will use it.
        ic.GetDrawer2D()->SetTransform( tworld );

        if (m_angle3d > 0)
        {
            cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2,  rec->GetHeight()/2));
            cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2+ cos(m_angle3d-wxPI/30)*m_depth, rec->GetHeight()/2+ sin(m_angle3d-wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, rec->GetHeight()/2+ sin(m_angle3d-wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, rec->GetHeight()/2));

            ic.GetDrawer2D()->DrawPolygon( cpoints, false, wxWINDING_RULE);
            cpoints->clear();
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, rec->GetHeight()/2));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, rec->GetHeight()/2+ sin(m_angle3d-wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, -rec->GetHeight()/2+ sin(m_angle3d)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, -rec->GetHeight()/2));

            ic.GetDrawer2D()->DrawPolygon( cpoints, false, wxWINDING_RULE);
        }
        else// (m_angle3d <= 0)
        {
            //set up a polygon in world coordinates that represents the cubicle
            cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2,  -rec->GetHeight()/2));
            cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2+ cos(m_angle3d+wxPI/30)*m_depth, -rec->GetHeight()/2+ sin(m_angle3d+wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, -rec->GetHeight()/2+ sin(m_angle3d+wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, -rec->GetHeight()/2));

            ic.GetDrawer2D()->DrawPolygon( cpoints, false, wxWINDING_RULE);
            cpoints->clear();
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, rec->GetHeight()/2));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, rec->GetHeight()/2+ sin(m_angle3d)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2+ cos(m_angle3d)*m_depth, -rec->GetHeight()/2+ sin(m_angle3d+wxPI/30)*m_depth));
            cpoints->push_back( new a2dLineSegment( rec->GetWidth()/2, -rec->GetHeight()/2));

            ic.GetDrawer2D()->DrawPolygon( cpoints, false, wxWINDING_RULE);
        }

        cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2,  -rec->GetHeight()/2));
        cpoints->push_back( new a2dLineSegment( -rec->GetWidth()/2,   rec->GetHeight()/2));
        cpoints->push_back( new a2dLineSegment(  rec->GetWidth()/2,   rec->GetHeight()/2));
        cpoints->push_back( new a2dLineSegment(  rec->GetWidth()/2,  -rec->GetHeight()/2));

        ic.GetDrawer2D()->DrawPolygon( cpoints, false, wxWINDING_RULE);

        cpoints->clear();

        delete cpoints;
    }
}

#if wxART2D_USE_CVGIO
void a2d3DShape::DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite )
{
    a2dCanvasObject::DoSave( parent, out, xmlparts, towrite );
    if ( xmlparts == a2dXmlSer_attrib )
    {
    }
    else
    {
        //only write the referenced object once
        if ( m_shape->GetCanvasDocument()==m_root )
        {
            m_shape->Save( this, out, towrite);
        }
    }
}

void a2d3DShape::DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts )
{
    a2dCanvasObject::DoLoad( parent, parser, xmlparts );
}

#endif //wxART2D_USE_CVGIO

bool a2d3DShape::DoIsHitWorld( a2dIterC& WXUNUSED(ic), a2dHitEvent& hitEvent )
{
    hitEvent.m_how = a2dHit::stock_fill;
    return true;
    //TODO
    //return  (m_shape->IsHitWorld( cworld, x, y, total, distance, margin, layer, mask ));
}

canobj3d.cpp Source File -- Tue Aug 31 17:56:21 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation