<?xml version="1.0" encoding="UTF-8"?>
<helpdocument version="1.0">

<!--***********************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 ***********************************************************-->




<meta>
      <topic id="textschart01three_d_viewxhp" indexer="include" status="PUBLISH">
         <title xml-lang="en-US" id="tit">3D View </title>
         <filename>/text/schart/01/three_d_view.xhp</filename>
      </topic>
   </meta>
   <body>
<bookmark xml-lang="en-US" branch="index" id="bm_id3156423"><bookmark_value>3D charts</bookmark_value>
      <bookmark_value>charts; 3D views</bookmark_value>
      <bookmark_value>illumination; 3D charts</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/.uno:View3D" id="bm_id3150449" localize="false"/><comment>mw made "3D charts;" a one level entry</comment>
<paragraph xml-lang="en-US" id="hd_id3464461" role="heading" level="1" l10n="NEW"><variable id="three_d_view"><link href="text/schart/01/three_d_view.xhp">3D View</link>
</variable></paragraph>
      <paragraph xml-lang="en-US" id="par_id6998809" role="paragraph" l10n="CHG">On the first page of the <link href="text/schart/01/wiz_chart_type.xhp">Chart Wizard</link> or in the context menu of a chart you can choose a chart type. <ahelp hid="." visibility="hidden">Opens a dialog to edit the properties of a three dimensional view for Column, Bar, Pie, and Area charts. For Line and XY (Scatter) charts you can see 3D lines.</ahelp><comment>must be AHID, see i80656</comment></paragraph>
      <section id="howtoget">
         <embed href="text/schart/00/00000004.xhp#wiz"/>
      </section>
      <embed href="text/shared/00/00000001.xhp#ShiftF1"/>
      <paragraph xml-lang="en-US" id="par_id6942045" role="paragraph" l10n="NEW">The chart preview responds to the new settings that you enter in the dialog. </paragraph>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id3806878" role="paragraph" l10n="NEW">When you leave the dialog with OK, the settings are applied permanently. </paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id130619" role="paragraph" l10n="NEW">When you leave the dialog with Cancel or Escape, the chart returns to the state when you opened the dialog.</paragraph>
         </listitem>
      </list>
      <paragraph xml-lang="en-US" id="par_id8081911" role="paragraph" l10n="NEW">For a 3D chart you can choose <item type="menuitem">Format - 3D View</item> to set perspective, appearance and illumination.</paragraph>
      <paragraph xml-lang="en-US" id="hd_id2924283" role="heading" level="2" l10n="NEW">Perspective</paragraph>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id5781731" role="paragraph" l10n="NEW">Enter the values for rotation of the chart on the three axes and for a perspective view.</paragraph>
         </listitem>
      </list>
      <paragraph xml-lang="en-US" id="par_id9999694" role="paragraph" l10n="NEW">Set all angles to 0 for a front view of the chart. Pie charts and donut charts are shown as circles.</paragraph>
      <paragraph xml-lang="en-US" id="par_id2861720" role="paragraph" l10n="NEW">With Right-angled axes enabled, you can rotate the chart contents only in X and Y direction, that is, parallel to the chart borders.</paragraph>
      <paragraph xml-lang="en-US" id="par_id2216559" role="paragraph" l10n="NEW">An x value of 90, with y and z set to 0, provides a view from top down to the chart. With x set to -90, you see the bottom of the chart.</paragraph>
      <paragraph xml-lang="en-US" id="par_id7869502" role="paragraph" l10n="NEW">The rotations are applied in the order first x, then y, last z.</paragraph>
      <paragraph xml-lang="en-US" id="par_id9852900" role="paragraph" l10n="NEW">When shading is enabled and you rotate a chart, the lights are rotated as if they are fixed to the chart.</paragraph>
      <paragraph xml-lang="en-US" id="par_id2578203" role="note" l10n="NEW">The rotation axes always relate to the page, not to the chart's axes. This is different from some other chart programs.</paragraph>
      <paragraph xml-lang="en-US" id="par_id4923245" role="paragraph" l10n="NEW">Select the Perspective check box to view the chart in central perspective as through a camera lens instead of using a parallel projection. </paragraph>
      <paragraph xml-lang="en-US" id="par_id3416547" role="paragraph" l10n="NEW">Set the focus length with the spin button. 100% gives a perspective view where a far edge in the chart looks approximately half as big as a near edge.</paragraph>
      <paragraph xml-lang="en-US" id="par_id3791924" role="note" l10n="NEW">Older versions of %PRODUCTNAME cannot display the percentage of perspective the same way as the current version.</paragraph><comment>Right-angled axes</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:CheckBox:TP_3D_SCENEGEOMETRY:CBX_RIGHT_ANGLED_AXES" id="bm_id5293740" localize="false"/>
<paragraph xml-lang="en-US" id="par_id7623828" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">If Right-angled axes is enabled, you can rotate the chart contents only in X and Y direction, that is, parallel to the chart borders. Right-angled axes is enabled by default for newly created 3D charts. Pie and Donut charts do not support right-angled axes.</ahelp></paragraph><comment>X rotation</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:MetricField:TP_3D_SCENEGEOMETRY:MTR_FLD_X_ROTATION" id="bm_id6549272" localize="false"/>
<paragraph xml-lang="en-US" id="par_id4721823" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Sets the rotation of the chart on the x axis. The preview responds to the new settings.</ahelp></paragraph><comment>Y rotation </comment>
<bookmark xml-lang="en-US" branch="hid/chart2:MetricField:TP_3D_SCENEGEOMETRY:MTR_FLD_Y_ROTATION" id="bm_id6529740" localize="false"/>
<paragraph xml-lang="en-US" id="par_id5806756" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Sets the rotation of the chart on the y axis. The preview responds to the new settings.</ahelp></paragraph><comment>z rotation</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:MetricField:TP_3D_SCENEGEOMETRY:MTR_FLD_Z_ROTATION" id="bm_id9121982" localize="false"/>
<paragraph xml-lang="en-US" id="par_id8915372" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Sets the rotation of the chart on the z axis. The preview responds to the new settings.</ahelp></paragraph><comment>perspective</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:CheckBox:TP_3D_SCENEGEOMETRY:CBX_PERSPECTIVE" id="bm_id2394482" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:MetricField:TP_3D_SCENEGEOMETRY:MTR_FLD_PERSPECTIVE" id="bm_id3808404" localize="false"/>
<paragraph xml-lang="en-US" id="par_id6070436" role="paragraph" l10n="CHG"><ahelp hid="." visibility="hidden">Mark the Perspective box to view the chart as through a camera lens. Use the spin button to set the percentage. With a high percentage nearer objects look bigger than more distant objects.</ahelp></paragraph>
      <paragraph xml-lang="en-US" id="hd_id7564012" role="heading" level="2" l10n="NEW">Appearance</paragraph>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id1186254" role="paragraph" l10n="NEW">Select a scheme from the list box.</paragraph>
         </listitem>
      </list>
      <paragraph xml-lang="en-US" id="par_id7432477" role="paragraph" l10n="NEW">By selecting a scheme, the check boxes and the light sources are set accordingly.</paragraph>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id7141026" role="paragraph" l10n="NEW">If you mark or unmark a combination of check boxes that is not given by the Realistic or Simple scheme, you create a Custom scheme.</paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id1579027" role="paragraph" l10n="NEW">Mark <emph>Shading</emph> to use the Gouraud method for rendering the surface, otherwise a flat method is used. </paragraph>
            <paragraph xml-lang="en-US" id="par_id5624561" role="paragraph" l10n="NEW">The flat method sets a single color and brightness for each polygon. The edges are visible, soft gradients and spot lights are not possible. </paragraph>
            <paragraph xml-lang="en-US" id="par_id5901058" role="paragraph" l10n="NEW">The Gouraud method applies gradients for a smoother, more realistic look.<comment>Regina: Need an external article on web, which describes the 3D engine in detail. Till that, the user should get some information on Gouraud and Flat.</comment></paragraph>
         </listitem>
      </list>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id8469191" role="paragraph" l10n="NEW">Mark <emph>Object Borders</emph> to draw lines along the edges.</paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id4407483" role="paragraph" l10n="NEW">Mark <emph>Rounded Edges</emph> to smooth the edges of box shapes.</paragraph>
         </listitem>
      </list><comment>Scheme</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:ListBox:TP_3D_SCENEAPPEARANCE:LB_SCHEME" id="bm_id631733" localize="false"/>
<paragraph xml-lang="en-US" id="par_id8531449" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Select a scheme from the list box, or click any of the check boxes below.</ahelp></paragraph><comment>Shading</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:CheckBox:TP_3D_SCENEAPPEARANCE:CB_SHADING" id="bm_id7811822" localize="false"/>
<paragraph xml-lang="en-US" id="par_id9183935" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Applies Gouraud shading if marked, or flat shading if unmarked.</ahelp></paragraph><comment>Object borders</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:CheckBox:TP_3D_SCENEAPPEARANCE:CB_OBJECTLINES" id="bm_id3640247" localize="false"/>
<paragraph xml-lang="en-US" id="par_id946684" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Shows borders around the areas by setting the line style to Solid.</ahelp></paragraph><comment>Rounded Edges</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:Checkbox:TP_3D_SCENEAPPEARANCE:CB_ROUNDEDEDGE" id="bm_id4585100" localize="false"/>
<paragraph xml-lang="en-US" id="par_id9607226" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Edges are rounded by 5%.</ahelp></paragraph>
      <paragraph xml-lang="en-US" id="hd_id1939451" role="heading" level="2" l10n="NEW">Illumination</paragraph>
      <paragraph xml-lang="en-US" id="par_id9038972" role="paragraph" l10n="NEW">Set the light sources for the 3D view.</paragraph>
      <list type="unordered">
         <listitem>
            <paragraph xml-lang="en-US" id="par_id6531266" role="paragraph" l10n="NEW">Click any of the eight buttons to switch a directed light source on or off.</paragraph>
            <paragraph xml-lang="en-US" id="par_id6173894" role="paragraph" l10n="NEW">By default, the second light source is switched on. It is the first of seven "normal", uniform light sources. The light source number one projects a specular light with highlights.</paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id2761314" role="paragraph" l10n="CHG">For the selected light source, you can then choose a color and intensity in the list box just below the eight buttons. The brightness values of all lights are added, so use dark colors when you enable multiple lights.</paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id3912778" role="paragraph" l10n="NEW">The small preview inside this tab page has two sliders to set the vertical and horizontal position of the selected light source. The light source always aims to the middle of the object.</paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id3163853" role="paragraph" l10n="NEW">The button in the corner of the small preview switches the internal illumination model between a sphere and a cube.<comment>Regina: Are you sure? I thought, that it only toggles the preview in the dialog.</comment></paragraph>
         </listitem>
         <listitem>
            <paragraph xml-lang="en-US" id="par_id121158" role="paragraph" l10n="NEW">Use the Ambient light list box to define the ambient light which shines with a uniform intensity from all directions.</paragraph>
         </listitem>
      </list><comment>preview right bar</comment>
<!-- removed HID 34145 33796 -->

<paragraph xml-lang="en-US" id="par_id2423780" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Drag the right slider to set the vertical height and direction of the selected light source.</ahelp></paragraph><comment>preview bottom bar</comment>
<!-- removed HID 34144 33794 -->

<paragraph xml-lang="en-US" id="par_id2569658" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Drag the bottom slider to set the horizontal position and direction of the selected light source.</ahelp></paragraph><comment>preview right bottom button</comment>
<!-- removed HID 34146 33795 -->

<paragraph xml-lang="en-US" id="par_id6394238" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Click to switch between an illumination model of a sphere or a cube.</ahelp></paragraph><comment>Light source</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_1" id="bm_id2334665" localize="false"/>
<paragraph xml-lang="en-US" id="par_id533768" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Click to enable or disable the specular light source with highlights.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_2" id="bm_id476393" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_3" id="bm_id2655720" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_4" id="bm_id3682058" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_5" id="bm_id5977965" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_6" id="bm_id3050325" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_7" id="bm_id9421979" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHT_8" id="bm_id1646778" localize="false"/>
<paragraph xml-lang="en-US" id="par_id7214270" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Click to enable or disable the uniform light source.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/chart2:ListBox:TP_3D_SCENEILLUMINATION:LB_LIGHTSOURCE" id="bm_id1601611" localize="false"/>
<paragraph xml-lang="en-US" id="par_id2186346" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Select a color for the selected light source.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_LIGHTSOURCE_COLOR" id="bm_id733359" localize="false"/>
<paragraph xml-lang="en-US" id="par_id1331217" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Select a color using the color dialog.</ahelp></paragraph><comment>Ambient light</comment>
<bookmark xml-lang="en-US" branch="hid/chart2:ListBox:TP_3D_SCENEILLUMINATION:LB_AMBIENTLIGHT" id="bm_id1228370" localize="false"/>
<paragraph xml-lang="en-US" id="par_id393993" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Select a color for the ambient light.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/chart2:ImageButton:TP_3D_SCENEILLUMINATION:BTN_AMBIENT_COLOR" id="bm_id879848" localize="false"/>
<paragraph xml-lang="en-US" id="par_id5871761" role="paragraph" l10n="NEW"><ahelp hid="." visibility="hidden">Select a color using the color dialog.</ahelp></paragraph>
      <section id="relatedtopics">
         <embed href="text/shared/guide/chart_insert.xhp#chart_insert"/>
         <embed href="text/schart/01/wiz_chart_type.xhp#wiz_chart_type"/>
         <embed href="text/schart/01/wiz_data_range.xhp#wiz_data_range"/>
         <embed href="text/schart/01/wiz_data_series.xhp#wiz_data_series"/>
         <embed href="text/schart/01/wiz_chart_elements.xhp#wiz_chart_elements"/>
      </section>
   </body>
</helpdocument>