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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! shader ext dx bridge for DxLib
//!

use crate::{dx::*, ext::tdx::*};

/// VertexShader
pub struct VertexShader {
  /// to be disposed
  pub d: bool,
  /// handle
  pub h: i32
}

/// Tr for VertexShader
impl Tr for VertexShader {
  /// as vertex shader
  fn as_vertex_shader(&self) -> VertexShader {
    VertexShader{d: false, h: self.h}
  }

  /// handle
  fn handle(&self) -> i32 { self.h }
  /// dispose
  fn dispose(&mut self) {
    if self.d && self.h != 0 {
      unsafe { DeleteShader(self.h); }
      self.h = 0;
    }
  }
}

/// Drop for VertexShader
impl Drop for VertexShader {
  /// drop
  fn drop(&mut self) { self.dispose(); }
}

/// VertexShader
impl VertexShader {
  /// load
  pub fn load(n: &String) -> Self {
    VertexShader{d: true, h: unsafe { LoadVertexShader(n.as_ptr()) } }
  }
  /// set shader
  pub fn set_shader(&self) {
    unsafe { SetUseVertexShader(self.h); }
  }
}

/// PixelShader
pub struct PixelShader {
  /// to be disposed
  pub d: bool,
  /// handle
  pub h: i32
}

/// Tr for PixelShader
impl Tr for PixelShader {
  /// as pixel shader
  fn as_pixel_shader(&self) -> PixelShader {
    PixelShader{d: false, h: self.h}
  }

  /// handle
  fn handle(&self) -> i32 { self.h }
  /// dispose
  fn dispose(&mut self) {
    if self.d && self.h != 0 {
      unsafe { DeleteShader(self.h); }
      self.h = 0;
    }
  }
}

/// Drop for PixelShader
impl Drop for PixelShader {
  /// drop
  fn drop(&mut self) { self.dispose(); }
}

/// PixelShader
impl PixelShader {
  /// load
  pub fn load(n: &String) -> Self {
    PixelShader{d: true, h: unsafe { LoadPixelShader(n.as_ptr()) } }
  }
  /// set shader
  pub fn set_shader(&self) {
    unsafe { SetUsePixelShader(self.h); }
  }
}

/// GeometryShader
pub struct GeometryShader {
  /// to be disposed
  pub d: bool,
  /// handle
  pub h: i32
}

/// Tr for GeometryShader
impl Tr for GeometryShader {
  /// as geometry shader
  fn as_geometry_shader(&self) -> GeometryShader {
    GeometryShader{d: false, h: self.h}
  }

  /// handle
  fn handle(&self) -> i32 { self.h }
  /// dispose
  fn dispose(&mut self) {
    if self.d && self.h != 0 {
      unsafe { DeleteShader(self.h); }
      self.h = 0;
    }
  }
}

/// Drop for GeometryShader
impl Drop for GeometryShader {
  /// drop
  fn drop(&mut self) { self.dispose(); }
}

/// GeometryShader
impl GeometryShader {
  /// load
  pub fn load(n: &String) -> Self {
    GeometryShader{d: true, h: unsafe { LoadGeometryShader(n.as_ptr()) } }
  }
  /// set shader
  pub fn set_shader(&self) {
    unsafe { SetUseGeometryShader(self.h); }
  }
}