 trees are conditioned and hardened to survive potentially harsh planting sites. This dedication to quality and service has resulted in the development of strong customer relationships and a high level of referrals. We thrive on the success of our customers plantings.
The nursery is set up as a "one stop tree shop" for the rural landowner and consequently supplies trees to farmers, small block owners, foresters, councils, landscapers etc. A wide range
of tree planting accessories such as fertiliser, stakes, pest repellents, tree protectors, tree ties, spades and herbicides are also available.
Trees are sold direct to the public through this website as well as via our catalogue, telephone, mail order and gate sales. We also sell to consultants, nurseries, landscapers and other companies that service this sector. The principal market is in Canterbury although trees are dispatched nationwide.
Currently Southern Woods employs 30 permanent staff plus a changing number of casual employees during the busy winter and spring period. A high caliber of staff is necessary to achieve a quality product and service, and all staff have relevant training and expertise to provide informed advice to customers whatever their needs. The combined plant knowledge of the business’s retail staff is more than 130 years, and they are keen to share that knowledge with customers.
The nursery currently produces well in excess of 1,000,000 trees per year of 500 species - varieties for shelter, forestry, tree crops, native revegetation, fuelwood, fodder, hedging and specimen trees.
Shelter belt trees and hedging.
This is a major
focus of Southern Woods and consequently we offer an extensive range of shelter trees in varying grades and prices to suit all situations. Customers have access to free information brochures on how to complete a successful planting, sample planting plans and on-site visits.
NZ Natives for revegetation. The growth in this market has been exponential in the last few years. The increased interest in New Zealand natives has added another dimension to the business, with staff involved in the collection and sourcing of New Zealand native seed all over Canterbury, allowing Southern Woods to offer a large variety of eco-source plants.
Forestry. The emphasis is on the supply of elite tree stocks of specialist timber species e.g. native totara and beech, clonal redwood, clonal cypress (ovensii, leylandii etc), ground durable eucalyptus species, and is a licensed supplier of Pinus radiata under the GF PLUS scheme.
We are involved in the Tree Crops Association, NZ Plant Propagators Assn, Farm Forestry Assn. We are the main supplier for the Cancer Society for their Sunsmart Programme and the Environmental Education for Resource Sustainability Trust Paper4Trees Project. We also sit on the Management Committee of Te ara Kakariki Greenways Trust.
The nursery is located on Main South Road, 3kms south of Templeton, Christchurch.
Winner: Selwyn District Council Enviromental Award
Southern Woods Tree Nursery is committed to improving and educating the local community on the conservation of indigenous plants and animals. Improvement is achieved via our own staff being continuously up-skilled on suitable native plant varieties for the Selwyn District, the importance of eco-sourcing and keeping accurate records that are completely transparent to all concerned. Education is achieved via free workshops, local sponsorship and donations, school competitions, networking with relevant groups for both large and small re-vegetation and the day-to-day dealings with customers.<gh_stars>1-10
pc.extend(pc, function () {
    'use strict';

    /**
     * @name pc.TransformFeedback
     * @class Transform feedback helper object
     * @description This object allows you to configure and use the transform feedback feature (WebGL2 only).
     *  How to use:<br>
     *  <ol>
     *  <li>First, check that you're on WebGL2, by looking at the <code>app.graphicsDevice.webgl2</code> value.</li>
     *  <li>Define the outputs in your vertex shader. The syntax is <code>out vec3 out_vertex_position</code>, note that there must be out_ in the name. You can then simply assign values to these outputs in VS. The order and size of shader outputs must match the output buffer layout.</li>
     *  <li>Create the shader using <code>pc.TransformFeedback.createShader(device, vsCode, yourShaderName)</code>.</li>
     *  <li>Create/acquire the input vertex buffer. Can be any pc.VertexBuffer, either manually created, or from a pc.Mesh.</li>
     *  <li>Create the pc.TransformFeedback object: <code>var tf = new pc.TransformFeedback(inputBuffer)</code>. This object will internally create an output buffer.</li>
     *  <li>Run the shader: <code>tf.process(shader)</code>. Shader will take the input buffer, process it and write to the ouput buffer, then the input/output buffers will be automatically swapped, so you'll immediately see the result.</li>
     *  </ol>
     * @example
     * // *** shader asset ***
     * attribute vec3 vertex_position;
     * attribute vec3 vertex_normal;
     * attribute vec2 vertex_texCoord0;
     * attribute vec4 vertex_tangent;
     * out vec3 out_vertex_position;
     * out vec3 out_vertex_normal;
     * out vec2 out_vertex_texCoord0;
     * out vec4 out_vertex_tangent;
     * void main(void) {
     *     // read position and normal, write new position (push away)
     *     out_vertex_position = vertex_position + vertex_normal * 0.01;
     *     // pass other attributes unchanged
     *     out_vertex_normal = vertex_normal;
     *     out_vertex_texCoord0 = vertex_texCoord0;
     *     out_vertex_tangent = vertex_tangent;
     * }
     * @example
     * // *** script asset ***
     * var TransformExample = pc.createScript('transformExample');
     *
     * // attribute that references shader asset and material
     * TransformExample.attributes.add('shaderCode', { type: 'asset', assetType:'shader' });
     * TransformExample.attributes.add('material', { type: 'asset', assetType:'material' });
     *
     * TransformExample.prototype.initialize = function() {
     *     var device = this.app.graphicsDevice;
     *     var mesh = pc.createTorus(device, { tubeRadius: 0.01, ringRadius: 3 });
     *     var node = new pc.GraphNode();
     *     var meshInstance = new pc.MeshInstance(node, mesh, this.material.resource);
     *     var model = new pc.Model();
     *     model.graph = node;
     *     model.meshInstances = [ meshInstance ];
     *     this.app.scene.addModel(model);
     *
     *     // if webgl2 is not supported, TF is not available
     *     if (!device.webgl2) return;
     *     var inputBuffer = mesh.vertexBuffer;
     *     this.tf = new pc.TransformFeedback(inputBuffer);
     *     this.shader = pc.TransformFeedback.createShader(device, this.shaderCode.resource, "tfMoveUp");
     * };
     *
     * TransformExample.prototype.update = function(dt) {
     *     if (!this.app.graphicsDevice.webgl2) return;
     *     this.tf.process(this.shader);
     * };
     * @param {pc.VertexBuffer} inputBuffer The input vertex buffer
     * @param {Number} [usage] The optional usage type of the output vertex buffer (see pc.BUFFER_*). pc.BUFFER_GPUDYNAMIC is recommended for continious update, and is the default value.
     */
    var TransformFeedback = function (inputBuffer, usage) {
        usage = usage || pc.BUFFER_GPUDYNAMIC;
        this.device = inputBuffer.device;
        var gl = this.device.gl;

        this._inputBuffer = inputBuffer;
        if (usage===pc.BUFFER_GPUDYNAMIC && inputBuffer.usage!==usage) {
            // have to recreate input buffer with other usage
            gl.bindBuffer(gl.ARRAY_BUFFER, inputBuffer.bufferId);
            gl.bufferData(gl.ARRAY_BUFFER, inputBuffer.storage, gl.DYNAMIC_COPY);
        }

        this._outputBuffer = new pc.VertexBuffer(inputBuffer.device, inputBuffer.format, inputBuffer.numVertices, usage, inputBuffer.storage);
    };

    /**
     * @function
     * @name pc.TransformFeedback#createShader
     * @description Creates a transform feedback ready vertex shader from code.
     * @param {pc.GraphicsDevice