Add new SkPoint3 class

tests/ImageFilterTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapDevice.h"
 #include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkComposeImageFilter.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkFlattenableSerialization.h"
 #include "SkGradientShader.h"
 #include "SkLightingImageFilter.h"
 #include "SkMatrixConvolutionImageFilter.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkOffsetImageFilter.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkPicture.h"
 #include "SkPictureImageFilter.h"
 #include "SkPictureRecorder.h"
+#include "SkPoint3.h"
 #include "SkReadBuffer.h"
 #include "SkRect.h"
 #include "SkRectShaderImageFilter.h"
 #include "SkTileImageFilter.h"
 #include "SkXfermodeImageFilter.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #include "SkGpuDevice.h"
@@ skipping 198 matching lines @@
 
     {
         // Tests pass by not asserting
         SkBitmap bitmap, result;
         make_small_bitmap(bitmap);
         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 
         {
             // This tests for :
             // 1 ) location at (0,0,1)
-            SkPoint3 location(0, 0, SK_Scalar1);
+            SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
             // 2 ) location and target at same value
-            SkPoint3 target(location.fX, location.fY, location.fZ);
+            SkPoint3 target = SkPoint3::Make(location.fX, location.fY, location.fZ);
             // 3 ) large negative specular exponent value
             SkScalar specularExponent = -1000;
 
             SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
             SkPaint paint;
             paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
                     location, target, specularExponent, 180,
                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
                     bmSrc))->unref();
             SkCanvas canvas(result);
@@ skipping 10 matching lines @@
     // Tests pass by not asserting.
     SkBitmap bitmap;
     bitmap.allocN32Pixels(100, 100);
     bitmap.eraseARGB(0, 0, 0, 0);
 
     SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
     SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect));
 
     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
-    SkPoint3 location(0, 0, SK_Scalar1);
-    SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
+    SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(3, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
 
     SkImageFilter* filters[] = {
         SkColorFilterImageFilter::Create(cf.get(), input.get(), &cropRect),
@@ skipping 112 matching lines @@
 
     test_negative_blur_sigma(&proxy, reporter);
 }
 
 DEF_TEST(ImageFilterDrawTiled, reporter) {
     // Check that all filters when drawn tiled (with subsequent clip rects) exactly
     // match the same filters drawn with a single full-canvas bitmap draw.
     // Tests pass by not asserting.
 
     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
-    SkPoint3 location(0, 0, SK_Scalar1);
-    SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
+    SkPoint3 location = SkPoint3::Make(0, 0, SK_Scalar1);
     SkScalar kernel[9] = {
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     };
     SkISize kernelSize = SkISize::Make(3, 3);
     SkScalar gain = SK_Scalar1, bias = 0;
     SkScalar five = SkIntToScalar(5);
 
     SkAutoTUnref<SkImageFilter> gradient_source(SkBitmapSource::Create(make_gradient_circle(64, 64)));
@@ skipping 780 matching lines @@
                                                          SkSurface::kNo_Budgeted,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          0,
                                                          &props,
                                                          SkGpuDevice::kUninit_InitContents));
     SkImageFilter::Proxy proxy(device);
 
     test_negative_blur_sigma(&proxy, reporter);
 }
 #endif