Stage3D程序的基本步骤

最新推荐文章于 2022-12-10 19:05:38 发布
最新推荐文章于 2022-12-10 19:05:38 发布
阅读量1.8k 收藏
点赞数
分类专栏： Flash Stage3D
本文介绍了Stage3D底层开发三角渲染的步骤，包括创建基础类、请求Context3D对象、设置显示缓冲区、初始化模型数据、创建缓冲并上传数据、编译顶点和片段着色器、创建Program3D实例、设置Shader数据、设置当前程序及渲染等，掌握此demo是后续开发基础。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、创建基础类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
        }
    }
}

为Stage3D设置这3个Frame rate，20/30/60

2、请求Context3D对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.events.Event;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
        }
    }
}

3、设置Context3D Display Buffer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.events.Event;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
        }
    }
}

4、初始化模型数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.events.Event;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

为了简单起见，定义的是一个三角形，可以看到两个数据，一个是meshVertexData，定义了每个定点的位置，和颜色值，一共三个点，每个点包含了6个数据，分别是x, y, z和r, g, b。meshVertexData包含了三个这样的数据。然后是meshIndexData，定义了链接这些定点的顺序，0， 1， 2，即按照顺序链接这三个定点，有点像小时候玩的连线游戏，是不是很简单就能理解了 :D

5、创建顶点缓冲和索引缓冲，并上传数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

createVertexBuffer，传入的几个定点，以及每个定点包含的数据量。根据现有demo定义的meshVertexData，一共有meshVertexData.lenght/ 6个顶点，其实也就是3个，然后每个定点包含了:x,y,z,r,g,b，6个数据。

6、编译Vertex Shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

示例包含了两行AGAL代码，使用了同一个opcode：mov，第一行将va0(将保存位置信息）输出到op，然后第二行将保存了颜色信息的va1赋值给v0，这种寄存器保存的信息共享于vertex shader和fragment shader。

7、编译Fragment Shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
        private var _fragmentShader:ByteArray;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
  
            var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _fragmentShader = fragmentShaderAssembler.assemble(
                    Context3DProgramType.FRAGMENT,
                    "mov oc, v0\n"
                );
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

此处的fragment shader只是将v0保存的颜色信息给输出出来。

8、创建Program3D实例，并上传Shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.Program3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
        private var _fragmentShader:ByteArray;
  
        private var _shaderProgram:Program3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
  
            var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _fragmentShader = fragmentShaderAssembler.assemble(
                    Context3DProgramType.FRAGMENT,
                    "mov oc, v0\n"
                );
  
            _shaderProgram = _renderContext.createProgram();
            _shaderProgram.upload(_vertexShader, _fragmentShader);
  
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

9、设置Shader数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.Context3DVertexBufferFormat;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.Program3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
        private var _fragmentShader:ByteArray;
  
        private var _shaderProgram:Program3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
  
            var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _fragmentShader = fragmentShaderAssembler.assemble(
                    Context3DProgramType.FRAGMENT,
                    "mov oc, v0\n"
                );
  
            _shaderProgram = _renderContext.createProgram();
            _shaderProgram.upload(_vertexShader, _fragmentShader);
  
            _renderContext.setVertexBufferAt(0, _vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
            _renderContext.setVertexBufferAt(1, _vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_3);
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

设置shader数据，分别设置了va0和va1。

10、设置当前的shader程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.Context3DVertexBufferFormat;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.Program3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
        private var _fragmentShader:ByteArray;
  
        private var _shaderProgram:Program3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
  
            var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _fragmentShader = fragmentShaderAssembler.assemble(
                    Context3DProgramType.FRAGMENT,
                    "mov oc, v0\n"
                );
  
            _shaderProgram = _renderContext.createProgram();
            _shaderProgram.upload(_vertexShader, _fragmentShader);
  
            _renderContext.setVertexBufferAt(0, _vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
            _renderContext.setVertexBufferAt(1, _vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_3);
  
            _renderContext.setProgram(_shaderProgram);
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

11、渲染

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package
{
    import com.adobe.utils.AGALMiniAssembler;
  
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.display3D.Context3D;
    import flash.display3D.Context3DProgramType;
    import flash.display3D.Context3DVertexBufferFormat;
    import flash.display3D.IndexBuffer3D;
    import flash.display3D.Program3D;
    import flash.display3D.VertexBuffer3D;
    import flash.events.Event;
    import flash.utils.ByteArray;
  
    [SWF(width="600",height="400",frameRate="60")]
    public class Stage3DBasic extends Sprite
    {
        private var _view_width:Number;
        private var _view_height:Number;
  
        private var _renderContext:Context3D;
  
        private var _meshVertexData:Vector.<Number>;
        private var _meshInexData:Vector.<uint>;
  
        private var _vertexBuffer:VertexBuffer3D;
        private var _indexBuffer:IndexBuffer3D;
  
        private var _vertexShader:ByteArray;
        private var _fragmentShader:ByteArray;
  
        private var _shaderProgram:Program3D;
  
        public function Stage3DBasic()
        {
            if(stage != null) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
  
        private function init(e:Event = null):void
        {
            if(hasEventListener(Event.ADDED_TO_STAGE))
                removeEventListener(Event.ADDED_TO_STAGE, init);
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
  
            _view_width = stage.stageWidth;
            _view_height = stage.stageHeight;
  
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
            stage.stage3Ds[0].requestContext3D();
        }
  
        private function onContext3DCreate(e:Event):void
        {
            _renderContext = stage.stage3Ds[0].context3D;
            _renderContext.configureBackBuffer(_view_width, _view_height, 0, true);
  
            initData();
  
            _vertexBuffer = _renderContext.createVertexBuffer(_meshVertexData.length / 6, 6);
            _vertexBuffer.uploadFromVector(_meshVertexData, 0, _meshVertexData.length / 6);
  
            _indexBuffer = _renderContext.createIndexBuffer(_meshInexData.length);
            _indexBuffer.uploadFromVector(_meshInexData, 0, _meshInexData.length);
  
            var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _vertexShader = vertexShaderAssembler.assemble(
                    Context3DProgramType.VERTEX,
                    "mov op, va0\n" +
                    "mov v0, va1\n"
                );
  
            var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
            _fragmentShader = fragmentShaderAssembler.assemble(
                    Context3DProgramType.FRAGMENT,
                    "mov oc, v0\n"
                );
  
            _shaderProgram = _renderContext.createProgram();
            _shaderProgram.upload(_vertexShader, _fragmentShader);
  
            _renderContext.setVertexBufferAt(0, _vertexBuffer, 0, Context3DVertexBufferFormat.FLOAT_3);
            _renderContext.setVertexBufferAt(1, _vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_3);
  
            _renderContext.setProgram(_shaderProgram);
  
            addEventListener(Event.ENTER_FRAME, render);
        }
  
        private function render(e:Event):void
        {
            _renderContext.clear(0,0,0,0);
            _renderContext.drawTriangles(_indexBuffer);
            _renderContext.present();
        }
  
        private function initData():void
        {
            _meshVertexData = Vector.<Number>([
                    //X,  Y,     Z,  r, g, b
                    -0.3, -0.3,  0,  1, 0, 0,
                    0,    0.3,   0,  0, 1, 0,
                    0.3, -0.3,   0,  0, 0, 1
                ]);
            _meshInexData = Vector.<uint>([
                    0, 1, 2
                ]);
        }
    }
}

最终结果：

虽然只是一个三角，但是这正是stage3d底层开发的一个开端，虽然步骤看上去很多，而且不同的情况下这些步骤的细节会有所调整，但是掌握好这个demo才能继续接下来的内容。下一篇文章我将继续Stage3D的底层开发，使用uv贴图。尽请期待。

【学习笔记】3D图形核心基础精炼版-12：stage3D实战-动态阴影 shadow mapping 和范例工程4
kdsrpg的专栏
04-28 2857
目的：     物体投影在另一个物体身上，而另一个物体可能是平的，但大多数都是不平的多边形物体，这里考虑的是后者，这样可以适用于大多数场合的投影。 预览效果： 原理：     这里使用的是shadow mapping方式，其原理如下：        1、将场景的深度值预先渲染到 以光源位置为原点、光线发射方向为观察方向的投影坐标系中，形成深度纹理。        2、再次渲
Stage3D新手入门教程
05-09
Adobe官方推荐的Stage3D新手入门教程（英文版） PDF 格式。 目前，没有发现中文版。
Stage3D 翻译系列之一: Stage3D是如何工作的（一）
12-03 202
Stage3D 翻译系列之一: Stage3D是如何工作的（一） 必备知识： 基本了解如何用Flash Professionnal创建应用程序； 有用ActionScript3进行开发的经验; 必备应用： Flash Builder 4.5 Pr...
Stage 3D：结缘、性能对比及相关开发框架推荐
houxq123的专栏
04-21 601
12年的时候，有篇这样的采访报道 http://www.infoq.com/cn/articles/interview-stage3d 当时的flash还是属于上升阶段，朝气蓬勃的 stage3d，workers，alchamy等技术都是新技术 虽然2017年还在用flash的我， 但是3d技术相通性还是挺高的 希望越来越好 摘抄： 廖诚： Flash Player
初探Stage3D(一) 3D渲染基础原理
weixin_33804990的博客
03-24 328
关于本文 本文主要想介绍一下3D渲染的基本流程，及怎样把一个三角形(0,1,0),(1,0,1),(0,0,1)最终渲染到屏幕上来。文章的目的是对3D渲染流程做一个简单的介绍,其中不涉及任何语言的API 参考资料 《3D游戏编程大师技巧》 PFD地址 http://download.youkuaiyun.com/detail/iamzealotwang/652886 (中文) 是我很早之前分享的一本...
Stage3D教程
12-18
Stage3D教程 3d的可以看看 很详细的教程
stage3d编程-基础3（网格，法线，面，顶点等）
alengan的专栏
11-07 2329
昨天谈到了矩阵的变换， 今天开始谈一下关于顶点，面，法线，网格等基本术语。如果有时间，还会写一个stage3d的demo。 　　1、顶点 　　在3d世界里面，基本单位就是三角形，为什么会是三角形？因为三个坐标可以构成一个三角形，而一个三角形则可以表示一个面。一个四边形则是两个三角形组合，再也找不到比三角形更小的几何图形可以用来表示一个面。在想象一下，一个立方体。比如你手边的魔
stage3d参考
09-26
flash 3d 代码参考代码参考 代码参考代码参考
Flash Stage3D 学习笔记（一）
myquark的专栏
08-06 2581
本文参考来源： http://www.adobe.com/devnet/flashplayer/articles/how-stage3d-works.html http://www.ashan.org/post-267.html http://www.pixelbender.cn/?p=381   1.Stage3D简介 Stage3D是Adobe为了提高的Flash 3D应用程序渲染
意大利佛罗伦萨大教堂Stage3D漫游
wkyb608的专栏
09-30 1748
Stage3D…Molehill…Beta版发布已几月了，现在离正式版发布已指日可待。这次我要发布一些Stage3D的例子，这回会是比较复杂点的，而不是一个方块那么简单。 现在让我给你透漏点背景信息，我们的办公室位于意大利的佛罗伦萨。我们很幸运，透过办公室的窗口能够
Stage3D程序原理解剖
学习记录
11-26 1954
Stage3D程序基础分析： 在我们编写第一个三角形程序之前，先粗略的了解下Stage3D程序的基本结构，这种结构也适用于其他底层3D编程和webGL编程。（WebGL是一种3D绘图标准，这种绘图技术标准允许把JavaScript和OpenGL ES 2.0结合在一起） 在使用底层3D API的时候，你必须知道一些硬件知识（作者指的是上一篇末尾的内容），例如V-RAM是你的显卡内存，而缓存区则
[Stage3D]硬件加速的径向模糊
04-13
NULL 博文链接：https://kenkao.iteye.com/blog/1731660
[转]Stage3D 翻译系列之六：一个真正的纯Stage3D应用（一）
hili2006的专栏
11-27 6710
前提 必备知识 熟悉Stage3D API，对其结构基本了解。对顶点和片段着色器，着色器语言基本了解。在阅读本文之前，强烈建议将本系列的前三篇教程完成（1、Stage3D如何工作 2、顶点和片段着色器 3、何为AGAL） 所需额外产品 Flex 4.5 SDK Download Flayer Player 11中的playerglobal.swc文件 Download Flash
Stage3D的优缺点
m_LeonWANG的专栏
01-11 1403
Stage3D的缺点和他的优点相同：一处开发多平台发布的能力。 因为用统一的API来面向所有的平台，需要保证一个应用适合所有平台，Stage3D需要根据图形处理能力在其所面向的平台中抽象出一个“平均”3D硬件设备，这样Stage3D无法利用多数强大的3D显卡中的先进功能，跟水桶理论一样一样的道理。 比如，当今的GPU硬件支持Shader Model（用于顶点和片段着色器的标准）版本4.0。但是
Stage3D如何工作
wkyb608的专栏
11-17 1071
原文地址：http://www.adobe.com/devnet/flas ... -stage3d-works.html 在如何使用Stage3D系列中的第一个教程中，你将会学习到有关在Flash Player 11中新引入的ActionScript API，该API允许在Flash中利用硬件加速进行3D渲染。在学习这个教程的过程中，你会对Stage3D是什么以及它是怎样工作的有一个大概的
【学习笔记】3D图形核心基础精炼版-9：stage3D实战-图片纹理
kdsrpg的专栏
04-09 1719
关于stage3D中的图片纹理数据： 1、stage3D实际处理的是Texture数据类型的纹理，这是一种压缩纹理，上传到GPU后直接使用的。 2、你可以通过BitmapData方式转化为Texture，使用Context3DTextureFormat.BGRA方式创建纹理，并用uploadFromBitmapData上传，这需要消耗一些性能，不过只要转化一次即可不用每帧渲染时都转化。
浅谈stage3D的三维成像功能
wkyb608的专栏
11-24 1170
首先，让我们了解一下三维成像的基本原理。 stage3D的坐标系是右手坐标系，同openGL，面对屏幕时，x轴指向右，y轴指向上，z轴指向屏幕外（你）。 这个坐标系是模型世界的坐标系，你可以将“1”当作任何单位来制定比例，但为了便于GPU计算，实际用于显示的立体区域，是一个x轴-1至1，y轴-1至1，z轴0至1的立方体，只有在这个立方体内的面片才会被后续步骤计算并显示在屏幕上，并且无论
[转]Stage3D 翻译系列之七:Stage3D和透视投影的使用
hili2006的专栏
11-27 4327
引言 在本教程中，你将了解透视的概念。 透视是开发使用3D渲染技术的Flash项目时使用的一个基本主题。你将充分了解如何使用Stage3D API并且通过使用Stage3D的透视技术来渲染3D世界。本教程是一个关于使用Stage3D的系列教程的一部分，并且它是基于之前描述如何渲染一个 三角形的若干教程的信息而编写的。通过使用透视技术渲染3D场景，你能够将该范例项目的功能提升至一个
4.Stage
qq_51748637的博客
12-10 952
Stage简单介绍（待补充）
3D电场线绘制：Stage3D技术演示
标签表明本演示程序使用了Stage3D技术进行三维电场线的绘制。 4. **Flex**： Flex是一个基于Flash的应用框架，使用ActionScript编程语言。它允许开发者构建富有交互性的Web应用和桌面应用。本演示可能是用Flex框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值